home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / itex < prev    next >
Encoding:
Text File  |  1990-06-08  |  58.2 KB  |  2,335 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. initialize () {
  5.     initialize_regmem 
  6.   schar i  ; 
  7.   integer k  ; 
  8.   hyphpointer z  ; 
  9.   xchr [ 32 ] = ' ' ; 
  10.   xchr [ 33 ] = '!' ; 
  11.   xchr [ 34 ] = '"' ; 
  12.   xchr [ 35 ] = '#' ; 
  13.   xchr [ 36 ] = '$' ; 
  14.   xchr [ 37 ] = '%' ; 
  15.   xchr [ 38 ] = '&' ; 
  16.   xchr [ 39 ] = '\'' ; 
  17.   xchr [ 40 ] = '(' ; 
  18.   xchr [ 41 ] = ')' ; 
  19.   xchr [ 42 ] = '*' ; 
  20.   xchr [ 43 ] = '+' ; 
  21.   xchr [ 44 ] = ',' ; 
  22.   xchr [ 45 ] = '-' ; 
  23.   xchr [ 46 ] = '.' ; 
  24.   xchr [ 47 ] = '/' ; 
  25.   xchr [ 48 ] = '0' ; 
  26.   xchr [ 49 ] = '1' ; 
  27.   xchr [ 50 ] = '2' ; 
  28.   xchr [ 51 ] = '3' ; 
  29.   xchr [ 52 ] = '4' ; 
  30.   xchr [ 53 ] = '5' ; 
  31.   xchr [ 54 ] = '6' ; 
  32.   xchr [ 55 ] = '7' ; 
  33.   xchr [ 56 ] = '8' ; 
  34.   xchr [ 57 ] = '9' ; 
  35.   xchr [ 58 ] = ':' ; 
  36.   xchr [ 59 ] = ';' ; 
  37.   xchr [ 60 ] = '<' ; 
  38.   xchr [ 61 ] = '=' ; 
  39.   xchr [ 62 ] = '>' ; 
  40.   xchr [ 63 ] = '?' ; 
  41.   xchr [ 64 ] = '@' ; 
  42.   xchr [ 65 ] = 'A' ; 
  43.   xchr [ 66 ] = 'B' ; 
  44.   xchr [ 67 ] = 'C' ; 
  45.   xchr [ 68 ] = 'D' ; 
  46.   xchr [ 69 ] = 'E' ; 
  47.   xchr [ 70 ] = 'F' ; 
  48.   xchr [ 71 ] = 'G' ; 
  49.   xchr [ 72 ] = 'H' ; 
  50.   xchr [ 73 ] = 'I' ; 
  51.   xchr [ 74 ] = 'J' ; 
  52.   xchr [ 75 ] = 'K' ; 
  53.   xchr [ 76 ] = 'L' ; 
  54.   xchr [ 77 ] = 'M' ; 
  55.   xchr [ 78 ] = 'N' ; 
  56.   xchr [ 79 ] = 'O' ; 
  57.   xchr [ 80 ] = 'P' ; 
  58.   xchr [ 81 ] = 'Q' ; 
  59.   xchr [ 82 ] = 'R' ; 
  60.   xchr [ 83 ] = 'S' ; 
  61.   xchr [ 84 ] = 'T' ; 
  62.   xchr [ 85 ] = 'U' ; 
  63.   xchr [ 86 ] = 'V' ; 
  64.   xchr [ 87 ] = 'W' ; 
  65.   xchr [ 88 ] = 'X' ; 
  66.   xchr [ 89 ] = 'Y' ; 
  67.   xchr [ 90 ] = 'Z' ; 
  68.   xchr [ 91 ] = '[' ; 
  69.   xchr [ 92 ] = '\\' ; 
  70.   xchr [ 93 ] = ']' ; 
  71.   xchr [ 94 ] = '^' ; 
  72.   xchr [ 95 ] = '_' ; 
  73.   xchr [ 96 ] = '`' ; 
  74.   xchr [ 97 ] = 'a' ; 
  75.   xchr [ 98 ] = 'b' ; 
  76.   xchr [ 99 ] = 'c' ; 
  77.   xchr [ 100 ] = 'd' ; 
  78.   xchr [ 101 ] = 'e' ; 
  79.   xchr [ 102 ] = 'f' ; 
  80.   xchr [ 103 ] = 'g' ; 
  81.   xchr [ 104 ] = 'h' ; 
  82.   xchr [ 105 ] = 'i' ; 
  83.   xchr [ 106 ] = 'j' ; 
  84.   xchr [ 107 ] = 'k' ; 
  85.   xchr [ 108 ] = 'l' ; 
  86.   xchr [ 109 ] = 'm' ; 
  87.   xchr [ 110 ] = 'n' ; 
  88.   xchr [ 111 ] = 'o' ; 
  89.   xchr [ 112 ] = 'p' ; 
  90.   xchr [ 113 ] = 'q' ; 
  91.   xchr [ 114 ] = 'r' ; 
  92.   xchr [ 115 ] = 's' ; 
  93.   xchr [ 116 ] = 't' ; 
  94.   xchr [ 117 ] = 'u' ; 
  95.   xchr [ 118 ] = 'v' ; 
  96.   xchr [ 119 ] = 'w' ; 
  97.   xchr [ 120 ] = 'x' ; 
  98.   xchr [ 121 ] = 'y' ; 
  99.   xchr [ 122 ] = 'z' ; 
  100.   xchr [ 123 ] = '{' ; 
  101.   xchr [ 124 ] = '|' ; 
  102.   xchr [ 125 ] = '}' ; 
  103.   xchr [ 126 ] = '~' ; 
  104.   xchr [ 0 ] = ' ' ; 
  105.   xchr [ 127 ] = ' ' ; 
  106.   {register integer for_end; i = 1 ; for_end = 31 ; if ( i <= for_end) do 
  107.     xchr [ i ] = chr ( i ) ; 
  108.   while ( i++ < for_end ) ; } 
  109.   {register integer for_end; i = 0 ; for_end = 127 ; if ( i <= for_end) do 
  110.     xord [ chr ( i ) ] = 127 ; 
  111.   while ( i++ < for_end ) ; } 
  112.   {register integer for_end; i = 1 ; for_end = 126 ; if ( i <= for_end) do 
  113.     xord [ xchr [ i ] ] = i ; 
  114.   while ( i++ < for_end ) ; } 
  115.   interaction = 3 ; 
  116.   deletionsallowed = true ; 
  117.   errorcount = 0 ; 
  118.   helpptr = 0 ; 
  119.   useerrhelp = false ; 
  120.   interrupt = 0 ; 
  121.   OKtointerrupt = true ; 
  122.     ;
  123. #ifdef DEBUG
  124.   wasmemend = memmin ; 
  125.   waslomax = memmin ; 
  126.   washimin = memmax ; 
  127.   panicking = false ; 
  128. #endif /* DEBUG */
  129.   nestptr = 0 ; 
  130.   maxneststack = 0 ; 
  131.   curlist .modefield = 1 ; 
  132.   curlist .headfield = memtop - 1 ; 
  133.   curlist .tailfield = memtop - 1 ; 
  134.   curlist .auxfield = -65536000L ; 
  135.   curlist .mlfield = 0 ; 
  136.   curlist .pgfield = 0 ; 
  137.   shownmode = 0 ; 
  138.   pagecontents = 0 ; 
  139.   pagetail = memtop - 2 ; 
  140.   mem [ memtop - 2 ] .hh .v.RH = 0 ; 
  141.   lastglue = 65535L ; 
  142.   lastpenalty = 0 ; 
  143.   lastkern = 0 ; 
  144.   pagesofar [ 7 ] = 0 ; 
  145.   pagemaxdepth = 0 ; 
  146.   {register integer for_end; k = 5267 ; for_end = 5976 ; if ( k <= for_end) 
  147.   do 
  148.     xeqlevel [ k ] = 1 ; 
  149.   while ( k++ < for_end ) ; } 
  150.   nonewcontrolsequence = true ; 
  151.   hash [ 258 ] .v.LH = 0 ; 
  152.   hash [ 258 ] .v.RH = 0 ; 
  153.   {register integer for_end; k = 259 ; for_end = 3524 ; if ( k <= for_end) do 
  154.     hash [ k ] = hash [ 258 ] ; 
  155.   while ( k++ < for_end ) ; } 
  156.   saveptr = 0 ; 
  157.   curlevel = 1 ; 
  158.   curgroup = 0 ; 
  159.   curboundary = 0 ; 
  160.   maxsavestack = 0 ; 
  161.   magset = 0 ; 
  162.   curmark [ 0 ] = 0 ; 
  163.   curmark [ 1 ] = 0 ; 
  164.   curmark [ 2 ] = 0 ; 
  165.   curmark [ 3 ] = 0 ; 
  166.   curmark [ 4 ] = 0 ; 
  167.   curval = 0 ; 
  168.   curvallevel = 0 ; 
  169.   radix = 0 ; 
  170.   {register integer for_end; k = 0 ; for_end = 16 ; if ( k <= for_end) do 
  171.     readopen [ k ] = 2 ; 
  172.   while ( k++ < for_end ) ; } 
  173.   condptr = 0 ; 
  174.   iflimit = 0 ; 
  175.   curif = 0 ; 
  176.   ifline = 0 ; 
  177.   TEXformatdefault = " plain.fmt" ; 
  178.   {register integer for_end; k = 0 ; for_end = fontmax ; if ( k <= for_end) 
  179.   do 
  180.     fontused [ k ] = false ; 
  181.   while ( k++ < for_end ) ; } 
  182.   nullcharacter .b0 = 0 ; 
  183.   nullcharacter .b1 = 0 ; 
  184.   nullcharacter .b2 = 0 ; 
  185.   nullcharacter .b3 = 0 ; 
  186.   totalpages = 0 ; 
  187.   maxv = 0 ; 
  188.   maxh = 0 ; 
  189.   maxpush = 0 ; 
  190.   lastbop = -1 ; 
  191.   doingleaders = false ; 
  192.   deadcycles = 0 ; 
  193.   curs = -1 ; 
  194.   halfbuf = dvibufsize / 2 ; 
  195.   dvilimit = dvibufsize ; 
  196.   dviptr = 0 ; 
  197.   dvioffset = 0 ; 
  198.   dvigone = 0 ; 
  199.   downptr = 0 ; 
  200.   rightptr = 0 ; 
  201.   adjusttail = 0 ; 
  202.   packbeginline = 0 ; 
  203.   emptyfield .v.RH = 0 ; 
  204.   emptyfield .v.LH = 0 ; 
  205.   nulldelimiter .b0 = 0 ; 
  206.   nulldelimiter .b1 = 0 ; 
  207.   nulldelimiter .b2 = 0 ; 
  208.   nulldelimiter .b3 = 0 ; 
  209.   alignptr = 0 ; 
  210.   curalign = 0 ; 
  211.   curspan = 0 ; 
  212.   curloop = 0 ; 
  213.   curhead = 0 ; 
  214.   curtail = 0 ; 
  215.   {register integer for_end; z = 0 ; for_end = 307 ; if ( z <= for_end) do 
  216.     {
  217.       hyphword [ z ] = 0 ; 
  218.       hyphlist [ z ] = 0 ; 
  219.     } 
  220.   while ( z++ < for_end ) ; } 
  221.   hyphcount = 0 ; 
  222.   outputactive = false ; 
  223.   insertpenalties = 0 ; 
  224.   aftertoken = 0 ; 
  225.   longhelpseen = false ; 
  226.   formatident = 0 ; 
  227.   {register integer for_end; k = 0 ; for_end = 17 ; if ( k <= for_end) do 
  228.     writeopen [ k ] = false ; 
  229.   while ( k++ < for_end ) ; } 
  230.   editnamestart = 0 ; 
  231.     ;
  232. #ifdef INITEX
  233.   {register integer for_end; k = 1 ; for_end = 19 ; if ( k <= for_end) do 
  234.     mem [ k ] .cint = 0 ; 
  235.   while ( k++ < for_end ) ; } 
  236.   k = 0 ; 
  237.   while ( k <= 19 ) {
  238.       
  239.     mem [ k ] .hh .v.RH = 1 ; 
  240.     mem [ k ] .hh.b0 = 0 ; 
  241.     mem [ k ] .hh.b1 = 0 ; 
  242.     k = k + 4 ; 
  243.   } 
  244.   mem [ 6 ] .cint = 65536L ; 
  245.   mem [ 4 ] .hh.b0 = 1 ; 
  246.   mem [ 10 ] .cint = 65536L ; 
  247.   mem [ 8 ] .hh.b0 = 2 ; 
  248.   mem [ 14 ] .cint = 65536L ; 
  249.   mem [ 12 ] .hh.b0 = 1 ; 
  250.   mem [ 15 ] .cint = 65536L ; 
  251.   mem [ 12 ] .hh.b1 = 1 ; 
  252.   mem [ 18 ] .cint = -65536L ; 
  253.   mem [ 16 ] .hh.b0 = 1 ; 
  254.   rover = 20 ; 
  255.   mem [ rover ] .hh .v.RH = 65535L ; 
  256.   mem [ rover ] .hh .v.LH = 1000 ; 
  257.   mem [ rover + 1 ] .hh .v.LH = rover ; 
  258.   mem [ rover + 1 ] .hh .v.RH = rover ; 
  259.   lomemmax = rover + 1000 ; 
  260.   mem [ lomemmax ] .hh .v.RH = 0 ; 
  261.   mem [ lomemmax ] .hh .v.LH = 0 ; 
  262.   {register integer for_end; k = memtop - 13 ; for_end = memtop ; if ( k <= 
  263.   for_end) do 
  264.     mem [ k ] = mem [ lomemmax ] ; 
  265.   while ( k++ < for_end ) ; } 
  266.   mem [ memtop - 10 ] .hh .v.LH = 7359 ; 
  267.   mem [ memtop - 9 ] .hh .v.RH = 256 ; 
  268.   mem [ memtop - 9 ] .hh .v.LH = 0 ; 
  269.   mem [ memtop - 7 ] .hh.b0 = 1 ; 
  270.   mem [ memtop - 6 ] .hh .v.LH = 65535L ; 
  271.   mem [ memtop - 7 ] .hh.b1 = 0 ; 
  272.   mem [ memtop ] .hh.b1 = 255 ; 
  273.   mem [ memtop ] .hh.b0 = 1 ; 
  274.   mem [ memtop ] .hh .v.RH = memtop ; 
  275.   mem [ memtop - 2 ] .hh.b0 = 10 ; 
  276.   mem [ memtop - 2 ] .hh.b1 = 0 ; 
  277.   avail = 0 ; 
  278.   memend = memtop ; 
  279.   himemmin = memtop - 13 ; 
  280.   varused = 20 ; 
  281.   dynused = 14 ; 
  282.   eqtb [ 3525 ] .hh.b0 = 100 ; 
  283.   eqtb [ 3525 ] .hh .v.RH = 0 ; 
  284.   eqtb [ 3525 ] .hh.b1 = 0 ; 
  285.   {register integer for_end; k = 1 ; for_end = 3524 ; if ( k <= for_end) do 
  286.     eqtb [ k ] = eqtb [ 3525 ] ; 
  287.   while ( k++ < for_end ) ; } 
  288.   eqtb [ 3526 ] .hh .v.RH = 0 ; 
  289.   eqtb [ 3526 ] .hh.b1 = 1 ; 
  290.   eqtb [ 3526 ] .hh.b0 = 116 ; 
  291.   {register integer for_end; k = 3527 ; for_end = 4055 ; if ( k <= for_end) 
  292.   do 
  293.     eqtb [ k ] = eqtb [ 3526 ] ; 
  294.   while ( k++ < for_end ) ; } 
  295.   mem [ 0 ] .hh .v.RH = mem [ 0 ] .hh .v.RH + 530 ; 
  296.   eqtb [ 4056 ] .hh .v.RH = 0 ; 
  297.   eqtb [ 4056 ] .hh.b0 = 117 ; 
  298.   eqtb [ 4056 ] .hh.b1 = 1 ; 
  299.   {register integer for_end; k = 4057 ; for_end = 4321 ; if ( k <= for_end) 
  300.   do 
  301.     eqtb [ k ] = eqtb [ 3525 ] ; 
  302.   while ( k++ < for_end ) ; } 
  303.   eqtb [ 4322 ] .hh .v.RH = 0 ; 
  304.   eqtb [ 4322 ] .hh.b0 = 118 ; 
  305.   eqtb [ 4322 ] .hh.b1 = 1 ; 
  306.   {register integer for_end; k = 4323 ; for_end = 4577 ; if ( k <= for_end) 
  307.   do 
  308.     eqtb [ k ] = eqtb [ 4322 ] ; 
  309.   while ( k++ < for_end ) ; } 
  310.   eqtb [ 4578 ] .hh .v.RH = 0 ; 
  311.   eqtb [ 4578 ] .hh.b0 = 119 ; 
  312.   eqtb [ 4578 ] .hh.b1 = 1 ; 
  313.   {register integer for_end; k = 4579 ; for_end = 4626 ; if ( k <= for_end) 
  314.   do 
  315.     eqtb [ k ] = eqtb [ 4578 ] ; 
  316.   while ( k++ < for_end ) ; } 
  317.   eqtb [ 4627 ] .hh .v.RH = 0 ; 
  318.   eqtb [ 4627 ] .hh.b0 = 119 ; 
  319.   eqtb [ 4627 ] .hh.b1 = 1 ; 
  320.   {register integer for_end; k = 4628 ; for_end = 5266 ; if ( k <= for_end) 
  321.   do 
  322.     eqtb [ k ] = eqtb [ 4627 ] ; 
  323.   while ( k++ < for_end ) ; } 
  324.   {register integer for_end; k = 0 ; for_end = 127 ; if ( k <= for_end) do 
  325.     {
  326.       eqtb [ 4627 + k ] .hh .v.RH = 12 ; 
  327.       eqtb [ 5139 + k ] .hh .v.RH = k ; 
  328.       eqtb [ 5011 + k ] .hh .v.RH = 1000 ; 
  329.     } 
  330.   while ( k++ < for_end ) ; } 
  331.   eqtb [ 4640 ] .hh .v.RH = 5 ; 
  332.   eqtb [ 4659 ] .hh .v.RH = 10 ; 
  333.   eqtb [ 4719 ] .hh .v.RH = 0 ; 
  334.   eqtb [ 4664 ] .hh .v.RH = 14 ; 
  335.   eqtb [ 4754 ] .hh .v.RH = 15 ; 
  336.   eqtb [ 4627 ] .hh .v.RH = 9 ; 
  337.   {register integer for_end; k = 48 ; for_end = 57 ; if ( k <= for_end) do 
  338.     eqtb [ 5139 + k ] .hh .v.RH = k + 28672 ; 
  339.   while ( k++ < for_end ) ; } 
  340.   {register integer for_end; k = 65 ; for_end = 90 ; if ( k <= for_end) do 
  341.     {
  342.       eqtb [ 4627 + k ] .hh .v.RH = 11 ; 
  343.       eqtb [ 4627 + k + 32 ] .hh .v.RH = 11 ; 
  344.       eqtb [ 5139 + k ] .hh .v.RH = k + 28928 ; 
  345.       eqtb [ 5139 + k + 32 ] .hh .v.RH = k + 28960 ; 
  346.       eqtb [ 4755 + k ] .hh .v.RH = k + 32 ; 
  347.       eqtb [ 4755 + k + 32 ] .hh .v.RH = k + 32 ; 
  348.       eqtb [ 4883 + k ] .hh .v.RH = k ; 
  349.       eqtb [ 4883 + k + 32 ] .hh .v.RH = k ; 
  350.       eqtb [ 5011 + k ] .hh .v.RH = 999 ; 
  351.     } 
  352.   while ( k++ < for_end ) ; } 
  353.   {register integer for_end; k = 5267 ; for_end = 5572 ; if ( k <= for_end) 
  354.   do 
  355.     eqtb [ k ] .cint = 0 ; 
  356.   while ( k++ < for_end ) ; } 
  357.   eqtb [ 5284 ] .cint = 1000 ; 
  358.   eqtb [ 5268 ] .cint = 10000 ; 
  359.   eqtb [ 5308 ] .cint = 1 ; 
  360.   eqtb [ 5307 ] .cint = 25 ; 
  361.   eqtb [ 5312 ] .cint = 92 ; 
  362.   eqtb [ 5315 ] .cint = 13 ; 
  363.   {register integer for_end; k = 0 ; for_end = 127 ; if ( k <= for_end) do 
  364.     eqtb [ 5573 + k ] .cint = -1 ; 
  365.   while ( k++ < for_end ) ; } 
  366.   eqtb [ 5619 ] .cint = 0 ; 
  367.   {register integer for_end; k = 5701 ; for_end = 5976 ; if ( k <= for_end) 
  368.   do 
  369.     eqtb [ k ] .cint = 0 ; 
  370.   while ( k++ < for_end ) ; } 
  371.   hashused = 3258 ; 
  372.   cscount = 0 ; 
  373.   eqtb [ 3267 ] .hh.b0 = 115 ; 
  374.   hash [ 3267 ] .v.RH = 361 ; 
  375.   fontptr = 0 ; 
  376.   fmemptr = 7 ; 
  377.   fontname [ 0 ] = 654 ; 
  378.   fontarea [ 0 ] = 206 ; 
  379.   hyphenchar [ 0 ] = 45 ; 
  380.   skewchar [ 0 ] = -1 ; 
  381.   fontbc [ 0 ] = 1 ; 
  382.   fontec [ 0 ] = 0 ; 
  383.   fontsize [ 0 ] = 0 ; 
  384.   fontdsize [ 0 ] = 0 ; 
  385.   charbase [ 0 ] = 0 ; 
  386.   widthbase [ 0 ] = 0 ; 
  387.   heightbase [ 0 ] = 0 ; 
  388.   depthbase [ 0 ] = 0 ; 
  389.   italicbase [ 0 ] = 0 ; 
  390.   ligkernbase [ 0 ] = 0 ; 
  391.   kernbase [ 0 ] = 0 ; 
  392.   extenbase [ 0 ] = 0 ; 
  393.   fontglue [ 0 ] = 0 ; 
  394.   fontparams [ 0 ] = 7 ; 
  395.   parambase [ 0 ] = -1 ; 
  396.   {register integer for_end; k = 0 ; for_end = 6 ; if ( k <= for_end) do 
  397.     fontinfo [ k ] .cint = 0 ; 
  398.   while ( k++ < for_end ) ; } 
  399.   trieopptr = 0 ; 
  400.   trie [ 0 ] .v.RH = 0 ; 
  401.   trie [ 0 ] .b1 = 0 ; 
  402.   trie [ 0 ] .b0 = 0 ; 
  403.   {register integer for_end; k = 1 ; for_end = 127 ; if ( k <= for_end) do 
  404.     trie [ k ] = trie [ 0 ] ; 
  405.   while ( k++ < for_end ) ; } 
  406.   triemax = 127 ; 
  407.   hash [ 3258 ] .v.RH = 1038 ; 
  408.   formatident = 1103 ; 
  409.   hash [ 3266 ] .v.RH = 1138 ; 
  410.   eqtb [ 3266 ] .hh.b1 = 1 ; 
  411.   eqtb [ 3266 ] .hh.b0 = 112 ; 
  412.   eqtb [ 3266 ] .hh .v.RH = 0 ; 
  413. #endif /* INITEX */
  414. } 
  415. #ifdef INITEX
  416. boolean getstringsstarted () {
  417.     /* 30 10 */ register boolean Result; 
  418.   getstringsstarted_regmem 
  419.   schar k, l  ; 
  420.   char m, n  ; 
  421.   strnumber g  ; 
  422.   integer a  ; 
  423.   boolean c  ; 
  424.   poolptr = 0 ; 
  425.   strptr = 0 ; 
  426.   strstart [ 0 ] = 0 ; 
  427.   {register integer for_end; k = 0 ; for_end = 127 ; if ( k <= for_end) do 
  428.     {
  429.       if ( ( ( k < 32 ) || ( k > 126 ) ) ) 
  430.       {
  431.     {
  432.       strpool [ poolptr ] = 94 ; 
  433.       incr ( poolptr ) ; 
  434.     } 
  435.     {
  436.       strpool [ poolptr ] = 94 ; 
  437.       incr ( poolptr ) ; 
  438.     } 
  439.     if ( k < 64 ) 
  440.     {
  441.       strpool [ poolptr ] = k + 64 ; 
  442.       incr ( poolptr ) ; 
  443.     } 
  444.     else {
  445.         
  446.       strpool [ poolptr ] = k - 64 ; 
  447.       incr ( poolptr ) ; 
  448.     } 
  449.       } 
  450.       else {
  451.       
  452.     strpool [ poolptr ] = k ; 
  453.     incr ( poolptr ) ; 
  454.       } 
  455.       g = makestring () ; 
  456.     } 
  457.   while ( k++ < for_end ) ; } 
  458.   vstrcpy ( nameoffile + 1 , poolname ) ; 
  459.   if ( aopenin ( poolfile , poolpathspec ) ) 
  460.   {
  461.     c = false ; 
  462.     do {
  463.     { 
  464.     if ( eof ( poolfile ) ) 
  465.     {
  466.       wakeupterminal () ; 
  467. #ifdef RISC_OS
  468.       (void) os_fputs("! tex.pool has no check sum.", stderr ) ; 
  469. #else
  470.       (void) fprintf( stdout , "%s\n",  "! tex.pool has no check sum." ) ; 
  471. #endif
  472.       aclose ( poolfile ) ; 
  473.       Result = false ; 
  474.       return(Result) ; 
  475.     } 
  476.     read ( poolfile , m ) ; 
  477.     read ( poolfile , n ) ; 
  478.     if ( m == '*' ) 
  479.     {
  480.       a = 0 ; 
  481.       k = 1 ; 
  482.       while ( true ) {
  483.           
  484.         if ( ( xord [ n ] < 48 ) || ( xord [ n ] > 57 ) ) 
  485.         {
  486.           wakeupterminal () ; 
  487. #ifdef RISC_OS
  488.           (void) os_fputs("! tex.pool check sum doesn't have nine digits.",
  489.                        stderr) ; 
  490. #else
  491.           (void) fprintf( stdout , "%s\n",                "! tex.pool check sum doesn't have nine digits." ) ; 
  492. #endif
  493.           aclose ( poolfile ) ; 
  494.           Result = false ; 
  495.           return(Result) ; 
  496.         } 
  497.         a = 10 * a + xord [ n ] - 48 ; 
  498.         if ( k == 9 ) 
  499.         goto lab30 ; 
  500.         incr ( k ) ; 
  501.         read ( poolfile , n ) ; 
  502.       } 
  503.       lab30: if ( a != 67218746L ) 
  504.       {
  505.         wakeupterminal () ; 
  506. #ifdef RISC_OS
  507.         (void) os_fputs("! tex.pool doesn't match; tangle me again.", stderr) 
  508. #else
  509.         (void) fprintf( stdout , "%s\n",  "! tex.pool doesn't match; tangle me again." )
  510. #endif 
  511.         ; 
  512.         aclose ( poolfile ) ; 
  513.         Result = false ; 
  514.         return(Result) ; 
  515.       } 
  516.       c = true ; 
  517.     } 
  518.     else {
  519.         
  520.       if ( ( xord [ m ] < 48 ) || ( xord [ m ] > 57 ) || ( xord [ n ] < 48 
  521.       ) || ( xord [ n ] > 57 ) ) 
  522.       {
  523.         wakeupterminal () ; 
  524. #ifdef RISC_OS
  525.         (void) os_fputs("! tex.pool line doesn't begin with two digits.",stderr); 
  526. #else
  527.         (void) fprintf( stdout , "%s\n",              "! tex.pool line doesn't begin with two digits." ) ; 
  528. #endif
  529.         aclose ( poolfile ) ; 
  530.         Result = false ; 
  531.         return(Result) ; 
  532.       } 
  533.       l = xord [ m ] * 10 + xord [ n ] - 48 * 11 ; 
  534.       if ( poolptr + l + stringvacancies > poolsize ) 
  535.       {
  536.         wakeupterminal () ; 
  537. #ifdef RISC_OS
  538.         (void) os_fputs("! You have to increase POOLSIZE.", stderr); 
  539. #else
  540.         (void) fprintf( stdout , "%s\n",  "! You have to increase POOLSIZE." ) ; 
  541. #endif
  542.         aclose ( poolfile ) ; 
  543.         Result = false ; 
  544.         return(Result) ; 
  545.       } 
  546.       {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) 
  547.       do 
  548.         {
  549. #ifdef RISC_OS /* PENDING: LEAVE THESE FOR THE MOMENT */
  550. #endif
  551.           if ( eoln ( poolfile ) ) 
  552.           m = ' ' ; 
  553.           else read ( poolfile , m ) ; 
  554.           {
  555.         strpool [ poolptr ] = xord [ m ] ; 
  556.         incr ( poolptr ) ; 
  557.           } 
  558.         } 
  559.       while ( k++ < for_end ) ; } 
  560.       readln ( poolfile ) ; 
  561.       g = makestring () ; 
  562.     } 
  563.       } 
  564.     } while ( ! ( c ) ) ; 
  565.     aclose ( poolfile ) ; 
  566.     Result = true ; 
  567.   } 
  568.   else {
  569.       
  570.     wakeupterminal () ; 
  571. #ifdef RISC_OS
  572.     (void) os_fputs("! I can't read tex.pool.", stderr); 
  573. #else
  574.     (void) fprintf( stdout , "%s\n",  "! I can't read tex.pool." ) ; 
  575. #endif
  576.     Result = false ; 
  577.     return(Result) ; 
  578.   } 
  579.   return(Result) ; 
  580. } 
  581. #endif /* INITEX */
  582. #ifdef INITEX
  583. sortavail () {
  584.     sortavail_regmem 
  585.   halfword p, q, r  ; 
  586.   halfword oldrover  ; 
  587.   p = getnode ( 1073741824L ) ; 
  588.   p = mem [ rover + 1 ] .hh .v.RH ; 
  589.   mem [ rover + 1 ] .hh .v.RH = 65535L ; 
  590.   oldrover = rover ; 
  591.   while ( p != oldrover ) if ( p < rover ) 
  592.   {
  593.     q = p ; 
  594.     p = mem [ q + 1 ] .hh .v.RH ; 
  595.     mem [ q + 1 ] .hh .v.RH = rover ; 
  596.     rover = q ; 
  597.   } 
  598.   else {
  599.       
  600.     q = rover ; 
  601.     while ( mem [ q + 1 ] .hh .v.RH < p ) q = mem [ q + 1 ] .hh .v.RH ; 
  602.     r = mem [ p + 1 ] .hh .v.RH ; 
  603.     mem [ p + 1 ] .hh .v.RH = mem [ q + 1 ] .hh .v.RH ; 
  604.     mem [ q + 1 ] .hh .v.RH = p ; 
  605.     p = r ; 
  606.   } 
  607.   p = rover ; 
  608.   while ( mem [ p + 1 ] .hh .v.RH != 65535L ) {
  609.       
  610.     mem [ mem [ p + 1 ] .hh .v.RH + 1 ] .hh .v.LH = p ; 
  611.     p = mem [ p + 1 ] .hh .v.RH ; 
  612.   } 
  613.   mem [ p + 1 ] .hh .v.RH = rover ; 
  614.   mem [ rover + 1 ] .hh .v.LH = p ; 
  615. } 
  616. #endif /* INITEX */
  617. #ifdef INITEX
  618. zprimitive ( s , c , o ) 
  619. strnumber s ; 
  620. quarterword c ; 
  621. halfword o ; 
  622. {primitive_regmem 
  623.   poolpointer k  ; 
  624.   smallnumber j  ; 
  625.   smallnumber l  ; 
  626.   if ( s < 128 ) 
  627.   curval = s + 129 ; 
  628.   else {
  629.       
  630.     k = strstart [ s ] ; 
  631.     l = strstart [ s + 1 ] - k ; 
  632.     {register integer for_end; j = 0 ; for_end = l - 1 ; if ( j <= for_end) 
  633.     do 
  634.       buffer [ j ] = strpool [ k + j ] ; 
  635.     while ( j++ < for_end ) ; } 
  636.     curval = idlookup ( 0 , l ) ; 
  637.     {
  638.       decr ( strptr ) ; 
  639.       poolptr = strstart [ strptr ] ; 
  640.     } 
  641.     hash [ curval ] .v.RH = s ; 
  642.   } 
  643.   eqtb [ curval ] .hh.b1 = 1 ; 
  644.   eqtb [ curval ] .hh.b0 = c ; 
  645.   eqtb [ curval ] .hh .v.RH = o ; 
  646. } 
  647. #endif /* INITEX */
  648. #ifdef INITEX
  649. quarterword znewtrieop ( d , n , v ) 
  650. smallnumber d , n ; 
  651. quarterword v ; 
  652. {/* 10 */ register quarterword Result; newtrieop_regmem 
  653.   short h  ; 
  654.   quarterword u  ; 
  655.   h = abs ( toint ( n ) + 313 * toint ( d ) + 361 * toint ( v ) ) % 510 ; 
  656.   while ( true ) {
  657.       
  658.     u = trieophash [ h ] ; 
  659.     if ( u == 0 ) 
  660.     {
  661.       if ( trieopptr == 255 ) 
  662.       {
  663.     Result = 0 ; 
  664.     return(Result) ; 
  665.       } 
  666.       incr ( trieopptr ) ; 
  667.       hyfdistance [ trieopptr ] = d ; 
  668.       hyfnum [ trieopptr ] = n ; 
  669.       hyfnext [ trieopptr ] = v ; 
  670.       trieophash [ h ] = trieopptr ; 
  671.       Result = trieopptr ; 
  672.       return(Result) ; 
  673.     } 
  674.     if ( ( hyfdistance [ u ] == d ) && ( hyfnum [ u ] == n ) && ( hyfnext [ u 
  675.     ] == v ) ) 
  676.     {
  677.       Result = u ; 
  678.       return(Result) ; 
  679.     } 
  680.     if ( h > 0 ) 
  681.     decr ( h ) ; 
  682.     else h = 510 ; 
  683.   } 
  684.   return(Result) ; 
  685. } 
  686. triepointer ztrienode ( p ) 
  687. triepointer p ; 
  688. {/* 10 */ register triepointer Result; trienode_regmem 
  689.   triepointer h  ; 
  690.   triepointer q  ; 
  691.   h = abs ( toint ( triec [ p ] ) + 1009 * toint ( trieo [ p ] ) + 2718 * 
  692.   toint ( triel [ p ] ) + 3142 * toint ( trier [ p ] ) ) % triesize ; 
  693.   while ( true ) {
  694.       
  695.     q = triehash [ h ] ; 
  696.     if ( q == 0 ) 
  697.     {
  698.       triehash [ h ] = p ; 
  699.       Result = p ; 
  700.       return(Result) ; 
  701.     } 
  702.     if ( ( triec [ q ] == triec [ p ] ) && ( trieo [ q ] == trieo [ p ] ) && ( 
  703.     triel [ q ] == triel [ p ] ) && ( trier [ q ] == trier [ p ] ) ) 
  704.     {
  705.       Result = q ; 
  706.       return(Result) ; 
  707.     } 
  708.     if ( h > 0 ) 
  709.     decr ( h ) ; 
  710.     else h = triesize ; 
  711.   } 
  712.   return(Result) ; 
  713. } 
  714. triepointer zcompresstrie ( p ) 
  715. triepointer p ; 
  716. {register triepointer Result; compresstrie_regmem 
  717.   if ( p == 0 ) 
  718.   Result = 0 ; 
  719.   else {
  720.       
  721.     triel [ p ] = compresstrie ( triel [ p ] ) ; 
  722.     trier [ p ] = compresstrie ( trier [ p ] ) ; 
  723.     Result = trienode ( p ) ; 
  724.   } 
  725.   return(Result) ; 
  726. } 
  727. initpatternmemory () {
  728.     initpatternmemory_regmem 
  729.   short h  ; 
  730.   triepointer p  ; 
  731.   {register integer for_end; h = 0 ; for_end = 510 ; if ( h <= for_end) do 
  732.     trieophash [ h ] = 0 ; 
  733.   while ( h++ < for_end ) ; } 
  734.   trieopptr = 0 ; 
  735.   triel [ 0 ] = 0 ; 
  736.   triec [ 0 ] = 0 ; 
  737.   trieptr = 0 ; 
  738.   {register integer for_end; p = 0 ; for_end = triesize ; if ( p <= for_end) 
  739.   do 
  740.     triehash [ p ] = 0 ; 
  741.   while ( p++ < for_end ) ; } 
  742. } 
  743. inittriememory () {
  744.     inittriememory_regmem 
  745.   triepointer p  ; 
  746.   {register integer for_end; p = 0 ; for_end = trieptr ; if ( p <= for_end) 
  747.   do 
  748.     triehash [ p ] = 0 ; 
  749.   while ( p++ < for_end ) ; } 
  750.   triemax = 128 ; 
  751.   triemin = 128 ; 
  752.   trie [ 0 ] .v.RH = 1 ; 
  753.   trietaken [ 0 ] = false ; 
  754.   {register integer for_end; p = 1 ; for_end = 128 ; if ( p <= for_end) do 
  755.     {
  756.       trie [ p ] .v.LH = p - 1 ; 
  757.       trie [ p ] .v.RH = p + 1 ; 
  758.       trietaken [ p ] = false ; 
  759.     } 
  760.   while ( p++ < for_end ) ; } 
  761. } 
  762. zfirstfit ( p ) 
  763. triepointer p ; 
  764. {/* 45 40 */ firstfit_regmem 
  765.   triepointer h  ; 
  766.   triepointer z  ; 
  767.   triepointer q  ; 
  768.   ASCIIcode c  ; 
  769.   c = triec [ p ] ; 
  770.   if ( c < triemin ) 
  771.   triemin = c ; 
  772.   z = trie [ triemin - 1 ] .v.RH ; 
  773.   while ( true ) {
  774.       
  775.     if ( z < c ) 
  776.     goto lab45 ; 
  777.     h = z - c ; 
  778.     if ( triemax < h + 128 ) 
  779.     {
  780.       if ( triesize <= h + 128 ) 
  781.       overflow ( 801 , triesize ) ; 
  782.       do {
  783.       incr ( triemax ) ; 
  784.     trietaken [ triemax ] = false ; 
  785.     trie [ triemax ] .v.RH = triemax + 1 ; 
  786.     trie [ triemax ] .v.LH = triemax - 1 ; 
  787.       } while ( ! ( triemax == h + 128 ) ) ; 
  788.     } 
  789.     if ( trietaken [ h ] ) 
  790.     goto lab45 ; 
  791.     q = trier [ p ] ; 
  792.     while ( q > 0 ) {
  793.     
  794.       if ( trie [ h + triec [ q ] ] .v.RH == 0 ) 
  795.       goto lab45 ; 
  796.       q = trier [ q ] ; 
  797.     } 
  798.     goto lab40 ; 
  799.     lab45: z = trie [ z ] .v.RH ; 
  800.   } 
  801.   lab40: trietaken [ h ] = true ; 
  802.   triehash [ p ] = h ; 
  803.   q = p ; 
  804.   do {
  805.       z = h + triec [ q ] ; 
  806.     trie [ trie [ z ] .v.RH ] .v.LH = trie [ z ] .v.LH ; 
  807.     trie [ trie [ z ] .v.LH ] .v.RH = trie [ z ] .v.RH ; 
  808.     trie [ z ] .v.RH = 0 ; 
  809.     q = trier [ q ] ; 
  810.   } while ( ! ( q == 0 ) ) ; 
  811. } 
  812. ztriepack ( p ) 
  813. triepointer p ; 
  814. {triepack_regmem 
  815.   triepointer q  ; 
  816.   do {
  817.       q = triel [ p ] ; 
  818.     if ( ( q > 0 ) && ( triehash [ q ] == 0 ) ) 
  819.     {
  820.       firstfit ( q ) ; 
  821.       triepack ( q ) ; 
  822.     } 
  823.     p = trier [ p ] ; 
  824.   } while ( ! ( p == 0 ) ) ; 
  825. } 
  826. ztriefix ( p ) 
  827. triepointer p ; 
  828. {triefix_regmem 
  829.   triepointer q  ; 
  830.   ASCIIcode c  ; 
  831.   triepointer z  ; 
  832.   z = triehash [ p ] ; 
  833.   while ( p != 0 ) {
  834.       
  835.     q = triel [ p ] ; 
  836.     c = triec [ p ] ; 
  837.     trie [ z + c ] .v.RH = triehash [ q ] ; 
  838.     trie [ z + c ] .b1 = c ; 
  839.     trie [ z + c ] .b0 = trieo [ p ] ; 
  840.     if ( q > 0 ) 
  841.     triefix ( q ) ; 
  842.     p = trier [ p ] ; 
  843.   } 
  844. } 
  845. newpatterns () {
  846.     /* 30 31 */ newpatterns_regmem 
  847.   smallnumber k, l  ; 
  848.   boolean digitsensed  ; 
  849.   quarterword v  ; 
  850.   triepointer p, q  ; 
  851.   boolean firstchild  ; 
  852.   ASCIIcode c  ; 
  853.   triepointer r, s  ; 
  854.   twohalves h  ; 
  855.   scanleftbrace () ; 
  856.   initpatternmemory () ; 
  857.   k = 0 ; 
  858.   hyf [ 0 ] = 0 ; 
  859.   digitsensed = false ; 
  860.   while ( true ) {
  861.       
  862.     getxtoken () ; 
  863.     switch ( curcmd ) 
  864.     {case 11 : 
  865.     case 12 : 
  866.       if ( digitsensed || ( curchr < 48 ) || ( curchr > 57 ) ) 
  867.       {
  868.     if ( curchr == 46 ) 
  869.     curchr = 128 ; 
  870.     else {
  871.         
  872.       curchr = eqtb [ 4755 + curchr ] .hh .v.RH ; 
  873.       if ( curchr == 0 ) 
  874.       {
  875.         {
  876.           if ( interaction == 3 ) 
  877.           wakeupterminal () ; 
  878.           printnl ( 133 ) ; 
  879.           print ( 805 ) ; 
  880.         } 
  881.         {
  882.           helpptr = 1 ; 
  883.           helpline [ 0 ] = 804 ; 
  884.         } 
  885.         error () ; 
  886.         curchr = 128 ; 
  887.       } 
  888.     } 
  889.     if ( k < 63 ) 
  890.     {
  891.       incr ( k ) ; 
  892.       hc [ k ] = curchr - 1 ; 
  893.       hyf [ k ] = 0 ; 
  894.       digitsensed = false ; 
  895.     } 
  896.       } 
  897.       else {
  898.       
  899.     hyf [ k ] = curchr - 48 ; 
  900.     if ( k < 63 ) 
  901.     digitsensed = true ; 
  902.       } 
  903.       break ; 
  904.     case 10 : 
  905.     case 2 : 
  906.       {
  907.     if ( k > 0 ) 
  908.     {
  909.       if ( hc [ 1 ] == 127 ) 
  910.       hyf [ 0 ] = 0 ; 
  911.       if ( hc [ k ] == 127 ) 
  912.       hyf [ k ] = 0 ; 
  913.       l = k ; 
  914.       v = 0 ; 
  915.       while ( true ) {
  916.           
  917.         if ( hyf [ l ] != 0 ) 
  918.         v = newtrieop ( k - l , hyf [ l ] , v ) ; 
  919.         if ( l > 0 ) 
  920.         decr ( l ) ; 
  921.         else goto lab31 ; 
  922.       } 
  923.       lab31: ; 
  924.       q = 0 ; 
  925.       while ( l < k ) {
  926.           
  927.         incr ( l ) ; 
  928.         c = hc [ l ] ; 
  929.         p = triel [ q ] ; 
  930.         firstchild = true ; 
  931.         while ( ( p > 0 ) && ( c > triec [ p ] ) ) {
  932.         
  933.           q = p ; 
  934.           p = trier [ q ] ; 
  935.           firstchild = false ; 
  936.         } 
  937.         if ( ( p == 0 ) || ( c < triec [ p ] ) ) 
  938.         {
  939.           if ( trieptr == triesize ) 
  940.           overflow ( 801 , triesize ) ; 
  941.           incr ( trieptr ) ; 
  942.           trier [ trieptr ] = p ; 
  943.           p = trieptr ; 
  944.           triel [ p ] = 0 ; 
  945.           if ( firstchild ) 
  946.           triel [ q ] = p ; 
  947.           else trier [ q ] = p ; 
  948.           triec [ p ] = c ; 
  949.           trieo [ p ] = 0 ; 
  950.         } 
  951.         q = p ; 
  952.       } 
  953.       if ( trieo [ q ] != 0 ) 
  954.       {
  955.         {
  956.           if ( interaction == 3 ) 
  957.           wakeupterminal () ; 
  958.           printnl ( 133 ) ; 
  959.           print ( 806 ) ; 
  960.         } 
  961.         {
  962.           helpptr = 1 ; 
  963.           helpline [ 0 ] = 804 ; 
  964.         } 
  965.         error () ; 
  966.       } 
  967.       trieo [ q ] = v ; 
  968.     } 
  969.     if ( curcmd == 2 ) 
  970.     goto lab30 ; 
  971.     k = 0 ; 
  972.     hyf [ 0 ] = 0 ; 
  973.     digitsensed = false ; 
  974.       } 
  975.       break ; 
  976.       default: 
  977.       {
  978.     {
  979.       if ( interaction == 3 ) 
  980.       wakeupterminal () ; 
  981.       printnl ( 133 ) ; 
  982.       print ( 802 ) ; 
  983.     } 
  984.     printesc ( 803 ) ; 
  985.     {
  986.       helpptr = 1 ; 
  987.       helpline [ 0 ] = 804 ; 
  988.     } 
  989.     error () ; 
  990.       } 
  991.       break ; 
  992.     } 
  993.   } 
  994.   lab30: ; 
  995.   triel [ 0 ] = compresstrie ( triel [ 0 ] ) ; 
  996.   inittriememory () ; 
  997.   if ( triel [ 0 ] != 0 ) 
  998.   {
  999.     firstfit ( triel [ 0 ] ) ; 
  1000.     triepack ( triel [ 0 ] ) ; 
  1001.   } 
  1002.   r = 0 ; 
  1003.   while ( trietaken [ r ] ) incr ( r ) ; 
  1004.   triehash [ 0 ] = r ; 
  1005.   triefix ( triel [ 0 ] ) ; 
  1006.   r = 0 ; 
  1007.   h .v.RH = 0 ; 
  1008.   h .b0 = 0 ; 
  1009.   h .b1 = 0 ; 
  1010.   do {
  1011.       s = trie [ r ] .v.RH ; 
  1012.     trie [ r ] = h ; 
  1013.     r = s ; 
  1014.   } while ( ! ( r > triemax ) ) ; 
  1015. } 
  1016. #endif /* INITEX */
  1017. prefixedcommand () {
  1018.     /* 30 10 */ prefixedcommand_regmem 
  1019.   smallnumber a  ; 
  1020.   internalfontnumber f  ; 
  1021.   halfword j  ; 
  1022.   integer k  ; 
  1023.   halfword p, q  ; 
  1024.   integer n  ; 
  1025.   boolean e  ; 
  1026.   a = 0 ; 
  1027.   while ( curcmd == 92 ) {
  1028.       
  1029.     if ( ! odd ( a / curchr ) ) 
  1030.     a = a + curchr ; 
  1031.     do {
  1032.     getxtoken () ; 
  1033.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1034.     if ( curcmd <= 69 ) 
  1035.     {
  1036.       {
  1037.     if ( interaction == 3 ) 
  1038.     wakeupterminal () ; 
  1039.     printnl ( 133 ) ; 
  1040.     print ( 1027 ) ; 
  1041.       } 
  1042.       printcmdchr ( curcmd , curchr ) ; 
  1043.       printchar ( 39 ) ; 
  1044.       {
  1045.     helpptr = 1 ; 
  1046.     helpline [ 0 ] = 1028 ; 
  1047.       } 
  1048.       backerror () ; 
  1049.       return ; 
  1050.     } 
  1051.   } 
  1052.   if ( ( curcmd != 96 ) && ( a % 4 != 0 ) ) 
  1053.   {
  1054.     {
  1055.       if ( interaction == 3 ) 
  1056.       wakeupterminal () ; 
  1057.       printnl ( 133 ) ; 
  1058.       print ( 541 ) ; 
  1059.     } 
  1060.     printesc ( 1019 ) ; 
  1061.     print ( 1029 ) ; 
  1062.     printesc ( 1020 ) ; 
  1063.     print ( 1030 ) ; 
  1064.     printcmdchr ( curcmd , curchr ) ; 
  1065.     printchar ( 39 ) ; 
  1066.     {
  1067.       helpptr = 1 ; 
  1068.       helpline [ 0 ] = 1031 ; 
  1069.     } 
  1070.     error () ; 
  1071.   } 
  1072.   if ( eqtb [ 5310 ] .cint != 0 ) 
  1073.   if ( eqtb [ 5310 ] .cint < 0 ) 
  1074.   {
  1075.     if ( ( a >= 4 ) ) 
  1076.     a = a - 4 ; 
  1077.   } 
  1078.   else {
  1079.       
  1080.     if ( ! ( a >= 4 ) ) 
  1081.     a = a + 4 ; 
  1082.   } 
  1083.   switch ( curcmd ) 
  1084.   {case 86 : 
  1085.     if ( ( a >= 4 ) ) 
  1086.     geqdefine ( 4578 , 119 , curchr ) ; 
  1087.     else eqdefine ( 4578 , 119 , curchr ) ; 
  1088.     break ; 
  1089.   case 96 : 
  1090.     {
  1091.       if ( odd ( curchr ) && ! ( a >= 4 ) && ( eqtb [ 5310 ] .cint >= 0 ) ) 
  1092.       a = a + 4 ; 
  1093.       e = ( curchr >= 2 ) ; 
  1094.       getrtoken () ; 
  1095.       p = curcs ; 
  1096.       q = scantoks ( true , e ) ; 
  1097.       if ( ( a >= 4 ) ) 
  1098.       geqdefine ( p , 110 + ( a % 4 ) , defref ) ; 
  1099.       else eqdefine ( p , 110 + ( a % 4 ) , defref ) ; 
  1100.     } 
  1101.     break ; 
  1102.   case 93 : 
  1103.     {
  1104.       n = curchr ; 
  1105.       getrtoken () ; 
  1106.       p = curcs ; 
  1107.       if ( n == 0 ) 
  1108.       {
  1109.     do {
  1110.         gettoken () ; 
  1111.     } while ( ! ( curcmd != 10 ) ) ; 
  1112.     if ( curtok == 3133 ) 
  1113.     {
  1114.       gettoken () ; 
  1115.       if ( curcmd == 10 ) 
  1116.       gettoken () ; 
  1117.     } 
  1118.       } 
  1119.       else {
  1120.       
  1121.     gettoken () ; 
  1122.     q = curtok ; 
  1123.     gettoken () ; 
  1124.     backinput () ; 
  1125.     curtok = q ; 
  1126.     backinput () ; 
  1127.       } 
  1128.       if ( curcmd >= 110 ) 
  1129.       incr ( mem [ curchr ] .hh .v.LH ) ; 
  1130.       if ( ( a >= 4 ) ) 
  1131.       geqdefine ( p , curcmd , curchr ) ; 
  1132.       else eqdefine ( p , curcmd , curchr ) ; 
  1133.     } 
  1134.     break ; 
  1135.   case 94 : 
  1136.     {
  1137.       n = curchr ; 
  1138.       getrtoken () ; 
  1139.       p = curcs ; 
  1140.       if ( ( a >= 4 ) ) 
  1141.       geqdefine ( p , 0 , 256 ) ; 
  1142.       else eqdefine ( p , 0 , 256 ) ; 
  1143.       scanoptionalequals () ; 
  1144.       switch ( n ) 
  1145.       {case 0 : 
  1146.     {
  1147.       scancharnum () ; 
  1148.       if ( ( a >= 4 ) ) 
  1149.       geqdefine ( p , 67 , curval ) ; 
  1150.       else eqdefine ( p , 67 , curval ) ; 
  1151.     } 
  1152.     break ; 
  1153.       case 1 : 
  1154.     {
  1155.       scanfifteenbitint () ; 
  1156.       if ( ( a >= 4 ) ) 
  1157.       geqdefine ( p , 68 , curval ) ; 
  1158.       else eqdefine ( p , 68 , curval ) ; 
  1159.     } 
  1160.     break ; 
  1161.     default: 
  1162.     {
  1163.       scaneightbitint () ; 
  1164.       switch ( n ) 
  1165.       {case 2 : 
  1166.         if ( ( a >= 4 ) ) 
  1167.         geqdefine ( p , 72 , 5317 + curval ) ; 
  1168.         else eqdefine ( p , 72 , 5317 + curval ) ; 
  1169.         break ; 
  1170.       case 3 : 
  1171.         if ( ( a >= 4 ) ) 
  1172.         geqdefine ( p , 73 , 5721 + curval ) ; 
  1173.         else eqdefine ( p , 73 , 5721 + curval ) ; 
  1174.         break ; 
  1175.       case 4 : 
  1176.         if ( ( a >= 4 ) ) 
  1177.         geqdefine ( p , 74 , 3544 + curval ) ; 
  1178.         else eqdefine ( p , 74 , 3544 + curval ) ; 
  1179.         break ; 
  1180.       case 5 : 
  1181.         if ( ( a >= 4 ) ) 
  1182.         geqdefine ( p , 75 , 3800 + curval ) ; 
  1183.         else eqdefine ( p , 75 , 3800 + curval ) ; 
  1184.         break ; 
  1185.       case 6 : 
  1186.         if ( ( a >= 4 ) ) 
  1187.         geqdefine ( p , 71 , 4066 + curval ) ; 
  1188.         else eqdefine ( p , 71 , 4066 + curval ) ; 
  1189.         break ; 
  1190.       } 
  1191.     } 
  1192.     break ; 
  1193.       } 
  1194.     } 
  1195.     break ; 
  1196.   case 95 : 
  1197.     {
  1198.       scanint () ; 
  1199.       n = curval ; 
  1200.       if ( ! scankeyword ( 695 ) ) 
  1201.       {
  1202.     {
  1203.       if ( interaction == 3 ) 
  1204.       wakeupterminal () ; 
  1205.       printnl ( 133 ) ; 
  1206.       print ( 921 ) ; 
  1207.     } 
  1208.     {
  1209.       helpptr = 2 ; 
  1210.       helpline [ 1 ] = 1048 ; 
  1211.       helpline [ 0 ] = 1049 ; 
  1212.     } 
  1213.     error () ; 
  1214.       } 
  1215.       getrtoken () ; 
  1216.       p = curcs ; 
  1217.       readtoks ( n , p ) ; 
  1218.       if ( ( a >= 4 ) ) 
  1219.       geqdefine ( p , 110 , curval ) ; 
  1220.       else eqdefine ( p , 110 , curval ) ; 
  1221.     } 
  1222.     break ; 
  1223.   case 70 : 
  1224.   case 71 : 
  1225.     {
  1226.       q = curcs ; 
  1227.       if ( curcmd == 70 ) 
  1228.       {
  1229.     scaneightbitint () ; 
  1230.     p = 4066 + curval ; 
  1231.       } 
  1232.       else p = curchr ; 
  1233.       scanoptionalequals () ; 
  1234.       do {
  1235.       getxtoken () ; 
  1236.       } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1237.       if ( curcmd != 1 ) 
  1238.       {
  1239.     if ( curcmd == 70 ) 
  1240.     {
  1241.       scaneightbitint () ; 
  1242.       curcmd = 71 ; 
  1243.       curchr = 4066 + curval ; 
  1244.     } 
  1245.     if ( curcmd == 71 ) 
  1246.     {
  1247.       q = eqtb [ curchr ] .hh .v.RH ; 
  1248.       if ( q == 0 ) 
  1249.       if ( ( a >= 4 ) ) 
  1250.       geqdefine ( p , 100 , 0 ) ; 
  1251.       else eqdefine ( p , 100 , 0 ) ; 
  1252.       else {
  1253.           
  1254.         incr ( mem [ q ] .hh .v.LH ) ; 
  1255.         if ( ( a >= 4 ) ) 
  1256.         geqdefine ( p , 110 , q ) ; 
  1257.         else eqdefine ( p , 110 , q ) ; 
  1258.       } 
  1259.       goto lab30 ; 
  1260.     } 
  1261.       } 
  1262.       backinput () ; 
  1263.       curcs = q ; 
  1264.       q = scantoks ( false , false ) ; 
  1265.       if ( mem [ defref ] .hh .v.RH == 0 ) 
  1266.       {
  1267.     if ( ( a >= 4 ) ) 
  1268.     geqdefine ( p , 100 , 0 ) ; 
  1269.     else eqdefine ( p , 100 , 0 ) ; 
  1270.     {
  1271.       mem [ defref ] .hh .v.RH = avail ; 
  1272.       avail = defref ; 
  1273.     ;
  1274. #ifdef STAT
  1275.       decr ( dynused ) ; 
  1276. #endif /* STAT */
  1277.     } 
  1278.       } 
  1279.       else {
  1280.       
  1281.     if ( p == 4057 ) 
  1282.     {
  1283.       mem [ q ] .hh .v.RH = getavail () ; 
  1284.       q = mem [ q ] .hh .v.RH ; 
  1285.       mem [ q ] .hh .v.LH = 637 ; 
  1286.       q = getavail () ; 
  1287.       mem [ q ] .hh .v.LH = 379 ; 
  1288.       mem [ q ] .hh .v.RH = mem [ defref ] .hh .v.RH ; 
  1289.       mem [ defref ] .hh .v.RH = q ; 
  1290.     } 
  1291.     if ( ( a >= 4 ) ) 
  1292.     geqdefine ( p , 110 , defref ) ; 
  1293.     else eqdefine ( p , 110 , defref ) ; 
  1294.       } 
  1295.     } 
  1296.     break ; 
  1297.   case 72 : 
  1298.     {
  1299.       p = curchr ; 
  1300.       scanoptionalequals () ; 
  1301.       scanint () ; 
  1302.       if ( ( a >= 4 ) ) 
  1303.       geqworddefine ( p , curval ) ; 
  1304.       else eqworddefine ( p , curval ) ; 
  1305.     } 
  1306.     break ; 
  1307.   case 73 : 
  1308.     {
  1309.       p = curchr ; 
  1310.       scanoptionalequals () ; 
  1311.       scandimen ( false , false , false ) ; 
  1312.       if ( ( a >= 4 ) ) 
  1313.       geqworddefine ( p , curval ) ; 
  1314.       else eqworddefine ( p , curval ) ; 
  1315.     } 
  1316.     break ; 
  1317.   case 74 : 
  1318.   case 75 : 
  1319.     {
  1320.       p = curchr ; 
  1321.       n = curcmd ; 
  1322.       scanoptionalequals () ; 
  1323.       if ( n == 75 ) 
  1324.       scanglue ( 3 ) ; 
  1325.       else scanglue ( 2 ) ; 
  1326.       trapzeroglue () ; 
  1327.       if ( ( a >= 4 ) ) 
  1328.       geqdefine ( p , 116 , curval ) ; 
  1329.       else eqdefine ( p , 116 , curval ) ; 
  1330.     } 
  1331.     break ; 
  1332.   case 84 : 
  1333.     {
  1334.       if ( curchr == 4627 ) 
  1335.       n = 15 ; 
  1336.       else if ( curchr == 5139 ) 
  1337.       n = 32768L ; 
  1338.       else if ( curchr == 5011 ) 
  1339.       n = 32767 ; 
  1340.       else if ( curchr == 5573 ) 
  1341.       n = 16777215L ; 
  1342.       else n = 127 ; 
  1343.       p = curchr ; 
  1344.       scansevenbitint () ; 
  1345.       p = p + curval ; 
  1346.       scanoptionalequals () ; 
  1347.       scanint () ; 
  1348.       if ( ( ( curval < 0 ) && ( p < 5573 ) ) || ( curval > n ) ) 
  1349.       {
  1350.     {
  1351.       if ( interaction == 3 ) 
  1352.       wakeupterminal () ; 
  1353.       printnl ( 133 ) ; 
  1354.       print ( 1050 ) ; 
  1355.     } 
  1356.     printint ( curval ) ; 
  1357.     if ( p < 5573 ) 
  1358.     print ( 1051 ) ; 
  1359.     else print ( 1052 ) ; 
  1360.     printint ( n ) ; 
  1361.     {
  1362.       helpptr = 1 ; 
  1363.       helpline [ 0 ] = 1053 ; 
  1364.     } 
  1365.     error () ; 
  1366.     curval = 0 ; 
  1367.       } 
  1368.       if ( p < 5139 ) 
  1369.       if ( ( a >= 4 ) ) 
  1370.       geqdefine ( p , 119 , curval ) ; 
  1371.       else eqdefine ( p , 119 , curval ) ; 
  1372.       else if ( p < 5573 ) 
  1373.       if ( ( a >= 4 ) ) 
  1374.       geqdefine ( p , 119 , curval ) ; 
  1375.       else eqdefine ( p , 119 , curval ) ; 
  1376.       else if ( ( a >= 4 ) ) 
  1377.       geqworddefine ( p , curval ) ; 
  1378.       else eqworddefine ( p , curval ) ; 
  1379.     } 
  1380.     break ; 
  1381.   case 85 : 
  1382.     {
  1383.       p = curchr ; 
  1384.       scanfourbitint () ; 
  1385.       p = p + curval ; 
  1386.       scanoptionalequals () ; 
  1387.       scanfontident () ; 
  1388.       if ( ( a >= 4 ) ) 
  1389.       geqdefine ( p , 119 , curval ) ; 
  1390.       else eqdefine ( p , 119 , curval ) ; 
  1391.     } 
  1392.     break ; 
  1393.   case 88 : 
  1394.   case 89 : 
  1395.   case 90 : 
  1396.   case 91 : 
  1397.     doregistercommand ( a ) ; 
  1398.     break ; 
  1399.   case 97 : 
  1400.     {
  1401.       scaneightbitint () ; 
  1402.       if ( ( a >= 4 ) ) 
  1403.       savestack [ saveptr + 0 ] .cint = 1073742080L + curval ; 
  1404.       else savestack [ saveptr + 0 ] .cint = 1073741824L + curval ; 
  1405.       scanoptionalequals () ; 
  1406.       scanbox () ; 
  1407.     } 
  1408.     break ; 
  1409.   case 78 : 
  1410.     alteraux () ; 
  1411.     break ; 
  1412.   case 79 : 
  1413.     alterprevgraf () ; 
  1414.     break ; 
  1415.   case 80 : 
  1416.     alterpagesofar () ; 
  1417.     break ; 
  1418.   case 81 : 
  1419.     alterinteger () ; 
  1420.     break ; 
  1421.   case 82 : 
  1422.     alterboxdimen () ; 
  1423.     break ; 
  1424.   case 83 : 
  1425.     {
  1426.       scanoptionalequals () ; 
  1427.       scanint () ; 
  1428.       n = curval ; 
  1429.       if ( n <= 0 ) 
  1430.       p = 0 ; 
  1431.       else {
  1432.       
  1433.     p = getnode ( 2 * n + 1 ) ; 
  1434.     mem [ p ] .hh .v.LH = n ; 
  1435.     {register integer for_end; j = 1 ; for_end = n ; if ( j <= for_end) 
  1436.     do 
  1437.       {
  1438.         scandimen ( false , false , false ) ; 
  1439.         mem [ p + 2 * j - 1 ] .cint = curval ; 
  1440.         scandimen ( false , false , false ) ; 
  1441.         mem [ p + 2 * j ] .cint = curval ; 
  1442.       } 
  1443.     while ( j++ < for_end ) ; } 
  1444.       } 
  1445.       if ( ( a >= 4 ) ) 
  1446.       geqdefine ( 4056 , 117 , p ) ; 
  1447.       else eqdefine ( 4056 , 117 , p ) ; 
  1448.     } 
  1449.     break ; 
  1450.   case 98 : 
  1451.     if ( curchr == 1 ) 
  1452.     {
  1453.     ;
  1454. #ifdef INITEX
  1455.       newpatterns () ; 
  1456.       goto lab30 ; 
  1457. #endif /* INITEX */
  1458.       {
  1459.     if ( interaction == 3 ) 
  1460.     wakeupterminal () ; 
  1461.     printnl ( 133 ) ; 
  1462.     print ( 1062 ) ; 
  1463.       } 
  1464.       helpptr = 0 ; 
  1465.       error () ; 
  1466.       do {
  1467.       gettoken () ; 
  1468.       } while ( ! ( curcmd == 2 ) ) ; 
  1469.       return ; 
  1470.     } 
  1471.     else {
  1472.     
  1473.       newhyphexceptions () ; 
  1474.       goto lab30 ; 
  1475.     } 
  1476.     break ; 
  1477.   case 76 : 
  1478.     {
  1479.       findfontdimen ( true ) ; 
  1480.       k = curval ; 
  1481.       scanoptionalequals () ; 
  1482.       scandimen ( false , false , false ) ; 
  1483.       fontinfo [ k ] .cint = curval ; 
  1484.     } 
  1485.     break ; 
  1486.   case 77 : 
  1487.     {
  1488.       n = curchr ; 
  1489.       scanfontident () ; 
  1490.       f = curval ; 
  1491.       scanoptionalequals () ; 
  1492.       scanint () ; 
  1493.       if ( n == 0 ) 
  1494.       hyphenchar [ f ] = curval ; 
  1495.       else skewchar [ f ] = curval ; 
  1496.     } 
  1497.     break ; 
  1498.   case 87 : 
  1499.     newfont ( a ) ; 
  1500.     break ; 
  1501.   case 99 : 
  1502.     newinteraction () ; 
  1503.     break ; 
  1504.     default: 
  1505.     confusion ( 1026 ) ; 
  1506.     break ; 
  1507.   } 
  1508.   lab30: if ( aftertoken != 0 ) 
  1509.   {
  1510.     curtok = aftertoken ; 
  1511.     backinput () ; 
  1512.     aftertoken = 0 ; 
  1513.   } 
  1514. } 
  1515. #ifdef INITEX
  1516. storefmtfile () {
  1517.     /* 41 42 31 32 */ storefmtfile_regmem 
  1518.   integer j, k, l  ; 
  1519.   halfword p, q  ; 
  1520.   integer x  ; 
  1521.   if ( saveptr != 0 ) 
  1522.   {
  1523.     {
  1524.       if ( interaction == 3 ) 
  1525.       wakeupterminal () ; 
  1526.       printnl ( 133 ) ; 
  1527.       print ( 1104 ) ; 
  1528.     } 
  1529.     {
  1530.       helpptr = 1 ; 
  1531.       helpline [ 0 ] = 1105 ; 
  1532.     } 
  1533.     {
  1534.       if ( interaction == 3 ) 
  1535.       interaction = 2 ; 
  1536.       error () ; 
  1537.     ;
  1538. #ifdef DEBUG
  1539.       if ( interaction > 0 ) 
  1540.       debughelp () ; 
  1541. #endif /* DEBUG */
  1542.       history = 3 ; 
  1543.       jumpout () ; 
  1544.     } 
  1545.   } 
  1546.   selector = 21 ; 
  1547.   print ( 1116 ) ; 
  1548.   print ( jobname ) ; 
  1549.   printchar ( 32 ) ; 
  1550.   printint ( eqtb [ 5290 ] .cint % 100 ) ; 
  1551.   printchar ( 46 ) ; 
  1552.   printint ( eqtb [ 5289 ] .cint ) ; 
  1553.   printchar ( 46 ) ; 
  1554.   printint ( eqtb [ 5288 ] .cint ) ; 
  1555.   printchar ( 41 ) ; 
  1556.   if ( interaction == 0 ) 
  1557.   selector = 18 ; 
  1558.   else selector = 19 ; 
  1559.   {
  1560.     if ( poolptr + 1 > poolsize ) 
  1561.     overflow ( 128 , poolsize - initpoolptr ) ; 
  1562.   } 
  1563.   formatident = makestring () ; 
  1564.   packjobname ( 1117 ) ; 
  1565.   while ( ! wopenout ( fmtfile ) ) promptfilename ( 1118 , 1117 ) ; 
  1566.   printnl ( 1119 ) ; 
  1567.   print ( wmakenamestring ( fmtfile ) ) ; 
  1568.   {
  1569.     decr ( strptr ) ; 
  1570.     poolptr = strstart [ strptr ] ; 
  1571.   } 
  1572.   printnl ( formatident ) ; 
  1573.   putfmtint ( 67218746L ) ; 
  1574.   putfmtint ( 0 ) ; 
  1575.   putfmtint ( memtop ) ; 
  1576.   putfmtint ( 5976 ) ; 
  1577.   putfmtint ( 2551 ) ; 
  1578.   putfmtint ( 307 ) ; 
  1579.   putfmtint ( poolptr ) ; 
  1580.   putfmtint ( strptr ) ; 
  1581.   dumpthings ( strstart [ 0 ] , strptr + 1 ) ; 
  1582.   dumpthings ( strpool [ 0 ] , poolptr ) ; 
  1583.   println () ; 
  1584.   printint ( strptr ) ; 
  1585.   print ( 1106 ) ; 
  1586.   printint ( poolptr ) ; 
  1587.   sortavail () ; 
  1588.   varused = 0 ; 
  1589.   putfmtint ( lomemmax ) ; 
  1590.   putfmtint ( rover ) ; 
  1591.   p = 0 ; 
  1592.   q = rover ; 
  1593.   x = 0 ; 
  1594.   do {
  1595.       dumpthings ( mem [ p ] , q + 2 - p ) ; 
  1596.     x = x + q + 2 - p ; 
  1597.     varused = varused + q - p ; 
  1598.     p = q + mem [ q ] .hh .v.LH ; 
  1599.     q = mem [ q + 1 ] .hh .v.RH ; 
  1600.   } while ( ! ( q == rover ) ) ; 
  1601.   varused = varused + lomemmax - p ; 
  1602.   dynused = memend + 1 - himemmin ; 
  1603.   dumpthings ( mem [ p ] , lomemmax + 1 - p ) ; 
  1604.   x = x + lomemmax + 1 - p ; 
  1605.   putfmtint ( himemmin ) ; 
  1606.   putfmtint ( avail ) ; 
  1607.   dumpthings ( mem [ himemmin ] , memend + 1 - himemmin ) ; 
  1608.   x = x + memend + 1 - himemmin ; 
  1609.   p = avail ; 
  1610.   while ( p != 0 ) {
  1611.       
  1612.     decr ( dynused ) ; 
  1613.     p = mem [ p ] .hh .v.RH ; 
  1614.   } 
  1615.   putfmtint ( varused ) ; 
  1616.   putfmtint ( dynused ) ; 
  1617.   println () ; 
  1618.   printint ( x ) ; 
  1619.   print ( 1107 ) ; 
  1620.   printint ( varused ) ; 
  1621.   printchar ( 38 ) ; 
  1622.   printint ( dynused ) ; 
  1623.   k = 1 ; 
  1624.   do {
  1625.       j = k ; 
  1626.     while ( j < 5266 ) {
  1627.     
  1628.       if ( ( eqtb [ j ] .hh .v.RH == eqtb [ j + 1 ] .hh .v.RH ) && ( eqtb [ j 
  1629.       ] .hh.b0 == eqtb [ j + 1 ] .hh.b0 ) && ( eqtb [ j ] .hh.b1 == eqtb [ j + 
  1630.       1 ] .hh.b1 ) ) 
  1631.       goto lab41 ; 
  1632.       incr ( j ) ; 
  1633.     } 
  1634.     l = 5267 ; 
  1635.     goto lab31 ; 
  1636.     lab41: incr ( j ) ; 
  1637.     l = j ; 
  1638.     while ( j < 5266 ) {
  1639.     
  1640.       if ( ( eqtb [ j ] .hh .v.RH != eqtb [ j + 1 ] .hh .v.RH ) || ( eqtb [ j 
  1641.       ] .hh.b0 != eqtb [ j + 1 ] .hh.b0 ) || ( eqtb [ j ] .hh.b1 != eqtb [ j + 
  1642.       1 ] .hh.b1 ) ) 
  1643.       goto lab31 ; 
  1644.       incr ( j ) ; 
  1645.     } 
  1646.     lab31: putfmtint ( l - k ) ; 
  1647.     dumpthings ( eqtb [ k ] , l - k ) ; 
  1648.     k = j + 1 ; 
  1649.     putfmtint ( k - l ) ; 
  1650.   } while ( ! ( k == 5267 ) ) ; 
  1651.   do {
  1652.       j = k ; 
  1653.     while ( j < 5976 ) {
  1654.     
  1655.       if ( eqtb [ j ] .cint == eqtb [ j + 1 ] .cint ) 
  1656.       goto lab42 ; 
  1657.       incr ( j ) ; 
  1658.     } 
  1659.     l = 5977 ; 
  1660.     goto lab32 ; 
  1661.     lab42: incr ( j ) ; 
  1662.     l = j ; 
  1663.     while ( j < 5976 ) {
  1664.     
  1665.       if ( eqtb [ j ] .cint != eqtb [ j + 1 ] .cint ) 
  1666.       goto lab32 ; 
  1667.       incr ( j ) ; 
  1668.     } 
  1669.     lab32: putfmtint ( l - k ) ; 
  1670.     dumpthings ( eqtb [ k ] , l - k ) ; 
  1671.     k = j + 1 ; 
  1672.     putfmtint ( k - l ) ; 
  1673.   } while ( ! ( k > 5976 ) ) ; 
  1674.   putfmtint ( parloc ) ; 
  1675.   putfmtint ( writeloc ) ; 
  1676.   putfmtint ( hashused ) ; 
  1677.   cscount = 3257 - hashused ; 
  1678.   {register integer for_end; p = 258 ; for_end = hashused ; if ( p <= 
  1679.   for_end) do 
  1680.     if ( hash [ p ] .v.RH != 0 ) 
  1681.     {
  1682.       putfmtint ( p ) ; 
  1683.       putfmthh ( hash [ p ] ) ; 
  1684.       incr ( cscount ) ; 
  1685.     } 
  1686.   while ( p++ < for_end ) ; } 
  1687.   dumpthings ( hash [ hashused + 1 ] , 3524 - hashused ) ; 
  1688.   putfmtint ( cscount ) ; 
  1689.   println () ; 
  1690.   printint ( cscount ) ; 
  1691.   print ( 1108 ) ; 
  1692.   putfmtint ( fmemptr ) ; 
  1693.   {
  1694.     dumpthings ( fontinfo [ 0 ] , fmemptr ) ; 
  1695.     putfmtint ( fontptr ) ; 
  1696.     dumpthings ( fontcheck [ 0 ] , fontptr + 1 ) ; 
  1697.     dumpthings ( fontsize [ 0 ] , fontptr + 1 ) ; 
  1698.     dumpthings ( fontdsize [ 0 ] , fontptr + 1 ) ; 
  1699.     dumpthings ( fontparams [ 0 ] , fontptr + 1 ) ; 
  1700.     dumpthings ( hyphenchar [ 0 ] , fontptr + 1 ) ; 
  1701.     dumpthings ( skewchar [ 0 ] , fontptr + 1 ) ; 
  1702.     dumpthings ( fontname [ 0 ] , fontptr + 1 ) ; 
  1703.     dumpthings ( fontarea [ 0 ] , fontptr + 1 ) ; 
  1704.     dumpthings ( fontbc [ 0 ] , fontptr + 1 ) ; 
  1705.     dumpthings ( fontec [ 0 ] , fontptr + 1 ) ; 
  1706.     dumpthings ( charbase [ 0 ] , fontptr + 1 ) ; 
  1707.     dumpthings ( widthbase [ 0 ] , fontptr + 1 ) ; 
  1708.     dumpthings ( heightbase [ 0 ] , fontptr + 1 ) ; 
  1709.     dumpthings ( depthbase [ 0 ] , fontptr + 1 ) ; 
  1710.     dumpthings ( italicbase [ 0 ] , fontptr + 1 ) ; 
  1711.     dumpthings ( ligkernbase [ 0 ] , fontptr + 1 ) ; 
  1712.     dumpthings ( kernbase [ 0 ] , fontptr + 1 ) ; 
  1713.     dumpthings ( extenbase [ 0 ] , fontptr + 1 ) ; 
  1714.     dumpthings ( parambase [ 0 ] , fontptr + 1 ) ; 
  1715.     dumpthings ( fontglue [ 0 ] , fontptr + 1 ) ; 
  1716.     {register integer for_end; k = 0 ; for_end = fontptr ; if ( k <= for_end) 
  1717.     do 
  1718.       {
  1719.     printnl ( 1111 ) ; 
  1720.     printesc ( hash [ 3268 + k ] .v.RH ) ; 
  1721.     printchar ( 61 ) ; 
  1722.     printfilename ( fontname [ k ] , fontarea [ k ] , 206 ) ; 
  1723.     if ( fontsize [ k ] != fontdsize [ k ] ) 
  1724.     {
  1725.       print ( 598 ) ; 
  1726.       printscaled ( fontsize [ k ] ) ; 
  1727.       print ( 262 ) ; 
  1728.     } 
  1729.       } 
  1730.     while ( k++ < for_end ) ; } 
  1731.   } 
  1732.   println () ; 
  1733.   printint ( fmemptr - 7 ) ; 
  1734.   print ( 1109 ) ; 
  1735.   printint ( fontptr - 0 ) ; 
  1736.   print ( 1110 ) ; 
  1737.   if ( fontptr != 1 ) 
  1738.   printchar ( 115 ) ; 
  1739.   putfmtint ( hyphcount ) ; 
  1740.   {register integer for_end; k = 0 ; for_end = 307 ; if ( k <= for_end) do 
  1741.     if ( hyphword [ k ] != 0 ) 
  1742.     {
  1743.       putfmtint ( k ) ; 
  1744.       putfmtint ( hyphword [ k ] ) ; 
  1745.       putfmtint ( hyphlist [ k ] ) ; 
  1746.     } 
  1747.   while ( k++ < for_end ) ; } 
  1748.   putfmtint ( triemax ) ; 
  1749.   dumpthings ( trie [ 0 ] , triemax + 1 ) ; 
  1750.   putfmtint ( trieopptr ) ; 
  1751.   dumpthings ( hyfdistance [ 1 ] , trieopptr - 0 ) ; 
  1752.   dumpthings ( hyfnum [ 1 ] , trieopptr - 0 ) ; 
  1753.   dumpthings ( hyfnext [ 1 ] , trieopptr - 0 ) ; 
  1754.   println () ; 
  1755.   printint ( hyphcount ) ; 
  1756.   print ( 1112 ) ; 
  1757.   if ( hyphcount != 1 ) 
  1758.   printchar ( 115 ) ; 
  1759.   printnl ( 1113 ) ; 
  1760.   printint ( triemax ) ; 
  1761.   print ( 1114 ) ; 
  1762.   printint ( trieopptr ) ; 
  1763.   print ( 1115 ) ; 
  1764.   if ( trieopptr != 1 ) 
  1765.   printchar ( 115 ) ; 
  1766.   putfmtint ( interaction ) ; 
  1767.   putfmtint ( formatident ) ; 
  1768.   putfmtint ( 69069L ) ; 
  1769.   eqtb [ 5298 ] .cint = 0 ; 
  1770.   wclose ( fmtfile ) ; 
  1771. } 
  1772. #endif /* INITEX */
  1773. finalcleanup () {
  1774.     /* 10 */ finalcleanup_regmem 
  1775.   smallnumber c  ; 
  1776.   c = curchr ; 
  1777.   if ( jobname == 0 ) 
  1778.   openlogfile () ; 
  1779.   if ( curlevel > 1 ) 
  1780.   {
  1781.     printnl ( 40 ) ; 
  1782.     printesc ( 1121 ) ; 
  1783.     print ( 1122 ) ; 
  1784.     printint ( curlevel - 1 ) ; 
  1785.     printchar ( 41 ) ; 
  1786.   } 
  1787.   while ( condptr != 0 ) {
  1788.       
  1789.     printnl ( 40 ) ; 
  1790.     printesc ( 1121 ) ; 
  1791.     print ( 1123 ) ; 
  1792.     printcmdchr ( 104 , curif ) ; 
  1793.     if ( ifline != 0 ) 
  1794.     {
  1795.       print ( 1124 ) ; 
  1796.       printint ( ifline ) ; 
  1797.     } 
  1798.     print ( 1125 ) ; 
  1799.     ifline = mem [ condptr + 1 ] .cint ; 
  1800.     curif = mem [ condptr ] .hh.b1 ; 
  1801.     condptr = mem [ condptr ] .hh .v.RH ; 
  1802.   } 
  1803.   if ( history != 0 ) 
  1804.   if ( ( ( history == 1 ) || ( interaction < 3 ) ) ) 
  1805.   if ( selector == 19 ) 
  1806.   {
  1807.     selector = 17 ; 
  1808.     printnl ( 1126 ) ; 
  1809.     selector = 19 ; 
  1810.   } 
  1811.   if ( c == 1 ) 
  1812.   {
  1813.     ;
  1814. #ifdef INITEX
  1815.     storefmtfile () ; 
  1816.     return ; 
  1817. #endif /* INITEX */
  1818.     printnl ( 1127 ) ; 
  1819.     return ; 
  1820.   } 
  1821. } 
  1822. #ifdef INITEX
  1823. initprim () {
  1824.     initprim_regmem 
  1825.   nonewcontrolsequence = false ; 
  1826.   primitive ( 241 , 74 , 3526 ) ; 
  1827.   primitive ( 242 , 74 , 3527 ) ; 
  1828.   primitive ( 243 , 74 , 3528 ) ; 
  1829.   primitive ( 244 , 74 , 3529 ) ; 
  1830.   primitive ( 245 , 74 , 3530 ) ; 
  1831.   primitive ( 246 , 74 , 3531 ) ; 
  1832.   primitive ( 247 , 74 , 3532 ) ; 
  1833.   primitive ( 248 , 74 , 3533 ) ; 
  1834.   primitive ( 249 , 74 , 3534 ) ; 
  1835.   primitive ( 250 , 74 , 3535 ) ; 
  1836.   primitive ( 251 , 74 , 3536 ) ; 
  1837.   primitive ( 252 , 74 , 3537 ) ; 
  1838.   primitive ( 253 , 74 , 3538 ) ; 
  1839.   primitive ( 254 , 74 , 3539 ) ; 
  1840.   primitive ( 255 , 74 , 3540 ) ; 
  1841.   primitive ( 256 , 75 , 3541 ) ; 
  1842.   primitive ( 257 , 75 , 3542 ) ; 
  1843.   primitive ( 258 , 75 , 3543 ) ; 
  1844.   primitive ( 263 , 71 , 4057 ) ; 
  1845.   primitive ( 264 , 71 , 4058 ) ; 
  1846.   primitive ( 265 , 71 , 4059 ) ; 
  1847.   primitive ( 266 , 71 , 4060 ) ; 
  1848.   primitive ( 267 , 71 , 4061 ) ; 
  1849.   primitive ( 268 , 71 , 4062 ) ; 
  1850.   primitive ( 269 , 71 , 4063 ) ; 
  1851.   primitive ( 270 , 71 , 4064 ) ; 
  1852.   primitive ( 271 , 71 , 4065 ) ; 
  1853.   primitive ( 285 , 72 , 5267 ) ; 
  1854.   primitive ( 286 , 72 , 5268 ) ; 
  1855.   primitive ( 287 , 72 , 5269 ) ; 
  1856.   primitive ( 288 , 72 , 5270 ) ; 
  1857.   primitive ( 289 , 72 , 5271 ) ; 
  1858.   primitive ( 290 , 72 , 5272 ) ; 
  1859.   primitive ( 291 , 72 , 5273 ) ; 
  1860.   primitive ( 292 , 72 , 5274 ) ; 
  1861.   primitive ( 293 , 72 , 5275 ) ; 
  1862.   primitive ( 294 , 72 , 5276 ) ; 
  1863.   primitive ( 295 , 72 , 5277 ) ; 
  1864.   primitive ( 296 , 72 , 5278 ) ; 
  1865.   primitive ( 297 , 72 , 5279 ) ; 
  1866.   primitive ( 298 , 72 , 5280 ) ; 
  1867.   primitive ( 299 , 72 , 5281 ) ; 
  1868.   primitive ( 300 , 72 , 5282 ) ; 
  1869.   primitive ( 301 , 72 , 5283 ) ; 
  1870.   primitive ( 302 , 72 , 5284 ) ; 
  1871.   primitive ( 303 , 72 , 5285 ) ; 
  1872.   primitive ( 304 , 72 , 5286 ) ; 
  1873.   primitive ( 305 , 72 , 5287 ) ; 
  1874.   primitive ( 306 , 72 , 5288 ) ; 
  1875.   primitive ( 307 , 72 , 5289 ) ; 
  1876.   primitive ( 308 , 72 , 5290 ) ; 
  1877.   primitive ( 309 , 72 , 5291 ) ; 
  1878.   primitive ( 310 , 72 , 5292 ) ; 
  1879.   primitive ( 311 , 72 , 5293 ) ; 
  1880.   primitive ( 312 , 72 , 5294 ) ; 
  1881.   primitive ( 313 , 72 , 5295 ) ; 
  1882.   primitive ( 314 , 72 , 5296 ) ; 
  1883.   primitive ( 315 , 72 , 5297 ) ; 
  1884.   primitive ( 316 , 72 , 5298 ) ; 
  1885.   primitive ( 317 , 72 , 5299 ) ; 
  1886.   primitive ( 318 , 72 , 5300 ) ; 
  1887.   primitive ( 319 , 72 , 5301 ) ; 
  1888.   primitive ( 320 , 72 , 5302 ) ; 
  1889.   primitive ( 321 , 72 , 5303 ) ; 
  1890.   primitive ( 322 , 72 , 5304 ) ; 
  1891.   primitive ( 323 , 72 , 5305 ) ; 
  1892.   primitive ( 324 , 72 , 5306 ) ; 
  1893.   primitive ( 325 , 72 , 5307 ) ; 
  1894.   primitive ( 326 , 72 , 5308 ) ; 
  1895.   primitive ( 327 , 72 , 5309 ) ; 
  1896.   primitive ( 328 , 72 , 5310 ) ; 
  1897.   primitive ( 329 , 72 , 5311 ) ; 
  1898.   primitive ( 330 , 72 , 5312 ) ; 
  1899.   primitive ( 331 , 72 , 5313 ) ; 
  1900.   primitive ( 332 , 72 , 5314 ) ; 
  1901.   primitive ( 333 , 72 , 5315 ) ; 
  1902.   primitive ( 334 , 72 , 5316 ) ; 
  1903.   primitive ( 338 , 73 , 5701 ) ; 
  1904.   primitive ( 339 , 73 , 5702 ) ; 
  1905.   primitive ( 340 , 73 , 5703 ) ; 
  1906.   primitive ( 341 , 73 , 5704 ) ; 
  1907.   primitive ( 342 , 73 , 5705 ) ; 
  1908.   primitive ( 343 , 73 , 5706 ) ; 
  1909.   primitive ( 344 , 73 , 5707 ) ; 
  1910.   primitive ( 345 , 73 , 5708 ) ; 
  1911.   primitive ( 346 , 73 , 5709 ) ; 
  1912.   primitive ( 347 , 73 , 5710 ) ; 
  1913.   primitive ( 348 , 73 , 5711 ) ; 
  1914.   primitive ( 349 , 73 , 5712 ) ; 
  1915.   primitive ( 350 , 73 , 5713 ) ; 
  1916.   primitive ( 351 , 73 , 5714 ) ; 
  1917.   primitive ( 352 , 73 , 5715 ) ; 
  1918.   primitive ( 353 , 73 , 5716 ) ; 
  1919.   primitive ( 354 , 73 , 5717 ) ; 
  1920.   primitive ( 355 , 73 , 5718 ) ; 
  1921.   primitive ( 356 , 73 , 5719 ) ; 
  1922.   primitive ( 357 , 73 , 5720 ) ; 
  1923.   primitive ( 32 , 64 , 0 ) ; 
  1924.   primitive ( 47 , 44 , 0 ) ; 
  1925.   primitive ( 367 , 45 , 0 ) ; 
  1926.   primitive ( 368 , 89 , 0 ) ; 
  1927.   primitive ( 369 , 40 , 0 ) ; 
  1928.   primitive ( 370 , 41 , 0 ) ; 
  1929.   primitive ( 371 , 61 , 0 ) ; 
  1930.   primitive ( 372 , 16 , 0 ) ; 
  1931.   primitive ( 363 , 106 , 0 ) ; 
  1932.   primitive ( 373 , 15 , 0 ) ; 
  1933.   primitive ( 374 , 91 , 0 ) ; 
  1934.   primitive ( 364 , 66 , 0 ) ; 
  1935.   primitive ( 375 , 62 , 0 ) ; 
  1936.   hash [ 3260 ] .v.RH = 375 ; 
  1937.   eqtb [ 3260 ] = eqtb [ curval ] ; 
  1938.   primitive ( 376 , 101 , 0 ) ; 
  1939.   primitive ( 377 , 87 , 0 ) ; 
  1940.   primitive ( 378 , 76 , 0 ) ; 
  1941.   primitive ( 379 , 32 , 0 ) ; 
  1942.   primitive ( 380 , 36 , 0 ) ; 
  1943.   primitive ( 381 , 39 , 0 ) ; 
  1944.   primitive ( 198 , 37 , 0 ) ; 
  1945.   primitive ( 219 , 18 , 0 ) ; 
  1946.   primitive ( 382 , 46 , 0 ) ; 
  1947.   primitive ( 383 , 17 , 0 ) ; 
  1948.   primitive ( 384 , 54 , 0 ) ; 
  1949.   primitive ( 385 , 90 , 0 ) ; 
  1950.   primitive ( 386 , 34 , 0 ) ; 
  1951.   primitive ( 387 , 102 , 0 ) ; 
  1952.   primitive ( 203 , 55 , 0 ) ; 
  1953.   primitive ( 388 , 63 , 0 ) ; 
  1954.   primitive ( 273 , 83 , 0 ) ; 
  1955.   primitive ( 389 , 42 , 0 ) ; 
  1956.   primitive ( 390 , 79 , 0 ) ; 
  1957.   primitive ( 391 , 65 , 0 ) ; 
  1958.   primitive ( 392 , 95 , 0 ) ; 
  1959.   primitive ( 393 , 0 , 256 ) ; 
  1960.   hash [ 3265 ] .v.RH = 393 ; 
  1961.   eqtb [ 3265 ] = eqtb [ curval ] ; 
  1962.   primitive ( 394 , 97 , 0 ) ; 
  1963.   primitive ( 395 , 108 , 0 ) ; 
  1964.   primitive ( 272 , 70 , 0 ) ; 
  1965.   primitive ( 220 , 38 , 0 ) ; 
  1966.   primitive ( 396 , 33 , 0 ) ; 
  1967.   primitive ( 397 , 56 , 0 ) ; 
  1968.   primitive ( 398 , 35 , 0 ) ; 
  1969.   primitive ( 455 , 13 , 0 ) ; 
  1970.   parloc = curval ; 
  1971.   partoken = 4096 + parloc ; 
  1972.   primitive ( 487 , 103 , 0 ) ; 
  1973.   primitive ( 488 , 103 , 1 ) ; 
  1974.   primitive ( 489 , 109 , 0 ) ; 
  1975.   primitive ( 490 , 109 , 1 ) ; 
  1976.   primitive ( 491 , 109 , 2 ) ; 
  1977.   primitive ( 492 , 109 , 3 ) ; 
  1978.   primitive ( 493 , 109 , 4 ) ; 
  1979.   primitive ( 336 , 88 , 0 ) ; 
  1980.   primitive ( 359 , 88 , 1 ) ; 
  1981.   primitive ( 260 , 88 , 2 ) ; 
  1982.   primitive ( 261 , 88 , 3 ) ; 
  1983.   primitive ( 526 , 78 , 101 ) ; 
  1984.   primitive ( 527 , 78 , 1 ) ; 
  1985.   primitive ( 528 , 81 , 0 ) ; 
  1986.   primitive ( 529 , 81 , 1 ) ; 
  1987.   primitive ( 530 , 82 , 1 ) ; 
  1988.   primitive ( 531 , 82 , 3 ) ; 
  1989.   primitive ( 532 , 82 , 2 ) ; 
  1990.   primitive ( 533 , 69 , 0 ) ; 
  1991.   primitive ( 534 , 69 , 1 ) ; 
  1992.   primitive ( 535 , 69 , 2 ) ; 
  1993.   primitive ( 592 , 107 , 0 ) ; 
  1994.   primitive ( 593 , 107 , 1 ) ; 
  1995.   primitive ( 594 , 107 , 2 ) ; 
  1996.   primitive ( 595 , 107 , 3 ) ; 
  1997.   primitive ( 596 , 107 , 4 ) ; 
  1998.   primitive ( 597 , 107 , 5 ) ; 
  1999.   primitive ( 613 , 104 , 0 ) ; 
  2000.   primitive ( 614 , 104 , 1 ) ; 
  2001.   primitive ( 615 , 104 , 2 ) ; 
  2002.   primitive ( 616 , 104 , 3 ) ; 
  2003.   primitive ( 617 , 104 , 4 ) ; 
  2004.   primitive ( 618 , 104 , 5 ) ; 
  2005.   primitive ( 619 , 104 , 6 ) ; 
  2006.   primitive ( 620 , 104 , 7 ) ; 
  2007.   primitive ( 621 , 104 , 8 ) ; 
  2008.   primitive ( 622 , 104 , 9 ) ; 
  2009.   primitive ( 623 , 104 , 10 ) ; 
  2010.   primitive ( 624 , 104 , 11 ) ; 
  2011.   primitive ( 625 , 104 , 12 ) ; 
  2012.   primitive ( 626 , 104 , 13 ) ; 
  2013.   primitive ( 627 , 104 , 14 ) ; 
  2014.   primitive ( 628 , 104 , 15 ) ; 
  2015.   primitive ( 629 , 104 , 16 ) ; 
  2016.   primitive ( 630 , 105 , 2 ) ; 
  2017.   hash [ 3262 ] .v.RH = 630 ; 
  2018.   eqtb [ 3262 ] = eqtb [ curval ] ; 
  2019.   primitive ( 631 , 105 , 4 ) ; 
  2020.   primitive ( 632 , 105 , 3 ) ; 
  2021.   primitive ( 654 , 86 , 0 ) ; 
  2022.   hash [ 3268 ] .v.RH = 654 ; 
  2023.   eqtb [ 3268 ] = eqtb [ curval ] ; 
  2024.   primitive ( 751 , 4 , 128 ) ; 
  2025.   primitive ( 752 , 5 , 129 ) ; 
  2026.   hash [ 3259 ] .v.RH = 752 ; 
  2027.   eqtb [ 3259 ] = eqtb [ curval ] ; 
  2028.   primitive ( 753 , 5 , 130 ) ; 
  2029.   hash [ 3263 ] .v.RH = 754 ; 
  2030.   hash [ 3264 ] .v.RH = 754 ; 
  2031.   eqtb [ 3264 ] .hh.b0 = 9 ; 
  2032.   eqtb [ 3264 ] .hh .v.RH = memtop - 11 ; 
  2033.   eqtb [ 3264 ] .hh.b1 = 1 ; 
  2034.   eqtb [ 3263 ] = eqtb [ 3264 ] ; 
  2035.   eqtb [ 3263 ] .hh.b0 = 114 ; 
  2036.   primitive ( 818 , 80 , 0 ) ; 
  2037.   primitive ( 819 , 80 , 1 ) ; 
  2038.   primitive ( 820 , 80 , 2 ) ; 
  2039.   primitive ( 821 , 80 , 3 ) ; 
  2040.   primitive ( 822 , 80 , 4 ) ; 
  2041.   primitive ( 823 , 80 , 5 ) ; 
  2042.   primitive ( 824 , 80 , 6 ) ; 
  2043.   primitive ( 825 , 80 , 7 ) ; 
  2044.   primitive ( 873 , 14 , 0 ) ; 
  2045.   primitive ( 874 , 14 , 1 ) ; 
  2046.   primitive ( 875 , 26 , 4 ) ; 
  2047.   primitive ( 876 , 26 , 0 ) ; 
  2048.   primitive ( 877 , 26 , 1 ) ; 
  2049.   primitive ( 878 , 26 , 2 ) ; 
  2050.   primitive ( 879 , 26 , 3 ) ; 
  2051.   primitive ( 880 , 27 , 4 ) ; 
  2052.   primitive ( 881 , 27 , 0 ) ; 
  2053.   primitive ( 882 , 27 , 1 ) ; 
  2054.   primitive ( 883 , 27 , 2 ) ; 
  2055.   primitive ( 884 , 27 , 3 ) ; 
  2056.   primitive ( 204 , 28 , 5 ) ; 
  2057.   primitive ( 208 , 29 , 1 ) ; 
  2058.   primitive ( 210 , 30 , 99 ) ; 
  2059.   primitive ( 902 , 21 , 1 ) ; 
  2060.   primitive ( 903 , 21 , 0 ) ; 
  2061.   primitive ( 904 , 22 , 1 ) ; 
  2062.   primitive ( 905 , 22 , 0 ) ; 
  2063.   primitive ( 274 , 20 , 0 ) ; 
  2064.   primitive ( 906 , 20 , 1 ) ; 
  2065.   primitive ( 907 , 20 , 2 ) ; 
  2066.   primitive ( 813 , 20 , 3 ) ; 
  2067.   primitive ( 908 , 20 , 4 ) ; 
  2068.   primitive ( 815 , 20 , 5 ) ; 
  2069.   primitive ( 909 , 20 , 105 ) ; 
  2070.   primitive ( 910 , 31 , 99 ) ; 
  2071.   primitive ( 911 , 31 , 100 ) ; 
  2072.   primitive ( 912 , 31 , 101 ) ; 
  2073.   primitive ( 913 , 31 , 102 ) ; 
  2074.   primitive ( 928 , 43 , 1 ) ; 
  2075.   primitive ( 929 , 43 , 0 ) ; 
  2076.   primitive ( 938 , 25 , 12 ) ; 
  2077.   primitive ( 939 , 25 , 11 ) ; 
  2078.   primitive ( 940 , 25 , 10 ) ; 
  2079.   primitive ( 941 , 23 , 0 ) ; 
  2080.   primitive ( 942 , 23 , 1 ) ; 
  2081.   primitive ( 943 , 24 , 0 ) ; 
  2082.   primitive ( 944 , 24 , 1 ) ; 
  2083.   primitive ( 45 , 47 , 1 ) ; 
  2084.   primitive ( 217 , 47 , 0 ) ; 
  2085.   primitive ( 975 , 48 , 0 ) ; 
  2086.   primitive ( 976 , 48 , 1 ) ; 
  2087.   primitive ( 719 , 50 , 16 ) ; 
  2088.   primitive ( 720 , 50 , 17 ) ; 
  2089.   primitive ( 721 , 50 , 18 ) ; 
  2090.   primitive ( 722 , 50 , 19 ) ; 
  2091.   primitive ( 723 , 50 , 20 ) ; 
  2092.   primitive ( 724 , 50 , 21 ) ; 
  2093.   primitive ( 725 , 50 , 22 ) ; 
  2094.   primitive ( 726 , 50 , 23 ) ; 
  2095.   primitive ( 728 , 50 , 26 ) ; 
  2096.   primitive ( 727 , 50 , 27 ) ; 
  2097.   primitive ( 977 , 51 , 0 ) ; 
  2098.   primitive ( 731 , 51 , 1 ) ; 
  2099.   primitive ( 732 , 51 , 2 ) ; 
  2100.   primitive ( 714 , 53 , 0 ) ; 
  2101.   primitive ( 715 , 53 , 2 ) ; 
  2102.   primitive ( 716 , 53 , 4 ) ; 
  2103.   primitive ( 717 , 53 , 6 ) ; 
  2104.   primitive ( 995 , 52 , 0 ) ; 
  2105.   primitive ( 996 , 52 , 1 ) ; 
  2106.   primitive ( 997 , 52 , 2 ) ; 
  2107.   primitive ( 998 , 52 , 3 ) ; 
  2108.   primitive ( 999 , 52 , 4 ) ; 
  2109.   primitive ( 1000 , 52 , 5 ) ; 
  2110.   primitive ( 729 , 49 , 30 ) ; 
  2111.   primitive ( 730 , 49 , 31 ) ; 
  2112.   hash [ 3261 ] .v.RH = 730 ; 
  2113.   eqtb [ 3261 ] = eqtb [ curval ] ; 
  2114.   primitive ( 1019 , 92 , 1 ) ; 
  2115.   primitive ( 1020 , 92 , 2 ) ; 
  2116.   primitive ( 1021 , 92 , 4 ) ; 
  2117.   primitive ( 1022 , 96 , 0 ) ; 
  2118.   primitive ( 1023 , 96 , 1 ) ; 
  2119.   primitive ( 1024 , 96 , 2 ) ; 
  2120.   primitive ( 1025 , 96 , 3 ) ; 
  2121.   primitive ( 1039 , 93 , 0 ) ; 
  2122.   primitive ( 1040 , 93 , 1 ) ; 
  2123.   primitive ( 1041 , 94 , 0 ) ; 
  2124.   primitive ( 1042 , 94 , 1 ) ; 
  2125.   primitive ( 1043 , 94 , 2 ) ; 
  2126.   primitive ( 1044 , 94 , 3 ) ; 
  2127.   primitive ( 1045 , 94 , 4 ) ; 
  2128.   primitive ( 1046 , 94 , 5 ) ; 
  2129.   primitive ( 1047 , 94 , 6 ) ; 
  2130.   primitive ( 280 , 84 , 4627 ) ; 
  2131.   primitive ( 284 , 84 , 5139 ) ; 
  2132.   primitive ( 281 , 84 , 4755 ) ; 
  2133.   primitive ( 282 , 84 , 4883 ) ; 
  2134.   primitive ( 283 , 84 , 5011 ) ; 
  2135.   primitive ( 337 , 84 , 5573 ) ; 
  2136.   primitive ( 277 , 85 , 4579 ) ; 
  2137.   primitive ( 278 , 85 , 4595 ) ; 
  2138.   primitive ( 279 , 85 , 4611 ) ; 
  2139.   primitive ( 793 , 98 , 0 ) ; 
  2140.   primitive ( 803 , 98 , 1 ) ; 
  2141.   primitive ( 1063 , 77 , 0 ) ; 
  2142.   primitive ( 1064 , 77 , 1 ) ; 
  2143.   primitive ( 143 , 99 , 0 ) ; 
  2144.   primitive ( 144 , 99 , 1 ) ; 
  2145.   primitive ( 145 , 99 , 2 ) ; 
  2146.   primitive ( 1073 , 99 , 3 ) ; 
  2147.   primitive ( 1074 , 60 , 1 ) ; 
  2148.   primitive ( 1075 , 60 , 0 ) ; 
  2149.   primitive ( 1076 , 58 , 0 ) ; 
  2150.   primitive ( 1077 , 58 , 1 ) ; 
  2151.   primitive ( 1083 , 57 , 4755 ) ; 
  2152.   primitive ( 1084 , 57 , 4883 ) ; 
  2153.   primitive ( 1085 , 19 , 0 ) ; 
  2154.   primitive ( 1086 , 19 , 1 ) ; 
  2155.   primitive ( 1087 , 19 , 2 ) ; 
  2156.   primitive ( 1088 , 19 , 3 ) ; 
  2157.   primitive ( 1129 , 59 , 0 ) ; 
  2158.   primitive ( 452 , 59 , 1 ) ; 
  2159.   writeloc = curval ; 
  2160.   primitive ( 1130 , 59 , 2 ) ; 
  2161.   primitive ( 1131 , 59 , 3 ) ; 
  2162.   primitive ( 1132 , 59 , 4 ) ; 
  2163.   nonewcontrolsequence = true ; 
  2164. } 
  2165. #endif /* INITEX */
  2166. texbody () {
  2167.     /* 1 9998 9999 */ texbody_regmem 
  2168.   integer bufindx  ; 
  2169.   history = 3 ; 
  2170.   if ( readyalready == 314159L ) 
  2171.   goto lab1 ; 
  2172.   setpaths () ; 
  2173.   bad = 0 ; 
  2174.   if ( ( halferrorline < 30 ) || ( halferrorline > errorline - 15 ) ) 
  2175.   bad = 1 ; 
  2176.   if ( maxprintline < 60 ) 
  2177.   bad = 2 ; 
  2178.   if ( dvibufsize % 8 != 0 ) 
  2179.   bad = 3 ; 
  2180.   if ( 1100 > memtop ) 
  2181.   bad = 4 ; 
  2182.   if ( 2551 > 3000 ) 
  2183.   bad = 5 ; 
  2184.   if ( maxinopen >= 128 ) 
  2185.   bad = 6 ; 
  2186.     ;
  2187. #ifdef INITEX
  2188.   if ( ( memmin != 0 ) || ( memmax != memtop ) ) 
  2189.   bad = 10 ; 
  2190. #endif /* INITEX */
  2191.   if ( ( memmin > 0 ) || ( memmax < memtop ) ) 
  2192.   bad = 10 ; 
  2193.   if ( ( 0 > 0 ) || ( 255 < 127 ) ) 
  2194.   bad = 11 ; 
  2195.   if ( ( 0 > 0 ) || ( 65535L < 32767 ) ) 
  2196.   bad = 12 ; 
  2197.   if ( ( 0 < 0 ) || ( 255 > 65535L ) ) 
  2198.   bad = 13 ; 
  2199.   if ( ( memmin < 0 ) || ( memmax >= 65535L ) || ( -0 - memmin > 65536L ) ) 
  2200.   bad = 14 ; 
  2201.   if ( ( 0 < 0 ) || ( fontmax > 255 ) ) 
  2202.   bad = 15 ; 
  2203.   if ( fontmax > 256 ) 
  2204.   bad = 16 ; 
  2205.   if ( ( savesize > 65535L ) || ( maxstrings > 65535L ) ) 
  2206.   bad = 17 ; 
  2207.   if ( bufsize > 65535L ) 
  2208.   bad = 18 ; 
  2209.   if ( 255 < 255 ) 
  2210.   bad = 19 ; 
  2211.   if ( 7621 > 65535L ) 
  2212.   bad = 21 ; 
  2213.   if ( 9 > filenamesize ) 
  2214.   bad = 31 ; 
  2215.   if ( 2 * 65535L < memtop - memmin ) 
  2216.   bad = 41 ; 
  2217.   if ( bad > 0 ) 
  2218.   {
  2219. #ifdef RISC_OS
  2220.   /* PENDING: FIX THIS BY HAND */
  2221. /*
  2222.     (void) fprintf( stdout , "%s%s%ld\n",  "Ouch---my internal constants have been clobbered!" ,     "---case " , (long)bad ) ; 
  2223.  */
  2224. #else
  2225.     (void) fprintf( stdout , "%s%s%ld\n",  "Ouch---my internal constants have been clobbered!" ,     "---case " , (long)bad ) ; 
  2226. #endif
  2227.     goto lab9999 ; 
  2228.   } 
  2229.   initialize () ; 
  2230.     ;
  2231. #ifdef INITEX
  2232.   if ( ! getstringsstarted () ) 
  2233.   goto lab9999 ; 
  2234.   initprim () ; 
  2235. #endif /* INITEX */
  2236.   readyalready = 314159L ; 
  2237.   lab1: selector = 17 ; 
  2238.   tally = 0 ; 
  2239.   termoffset = 0 ; 
  2240.   fileoffset = 0 ; 
  2241. #ifdef RISC_OS
  2242.   (void) Fput(stdout, "This is TeX, C Version 2.9"); 
  2243.                                       /* ADDED a FPUT macro for this case! */
  2244. #else
  2245.   (void) fprintf( stdout ,  "%s", "This is TeX, C Version 2.9" ) ; 
  2246. #endif
  2247.   if ( formatident == 0 ) 
  2248. #ifdef RISC_OS
  2249.   (void) Fputs(stdout, " (no format preloaded)") ; 
  2250. #else
  2251.   (void) fprintf( stdout , "%s\n",  " (no format preloaded)" ) ; 
  2252. #endif
  2253.   else {
  2254.       
  2255.     print ( formatident ) ; 
  2256.     println () ; 
  2257.   } 
  2258.   termflush ( stdout ) ; 
  2259.   jobname = 0 ; 
  2260.   nameinprogress = false ; 
  2261.   outputfilename = 0 ; 
  2262.   {
  2263.     {
  2264.       inputptr = 0 ; 
  2265.       maxinstack = 0 ; 
  2266.       inopen = 0 ; 
  2267.       maxbufstack = 0 ; 
  2268.       paramptr = 0 ; 
  2269.       maxparamstack = 0 ; 
  2270.       bufindx = bufsize ; 
  2271.       do {
  2272.       buffer [ bufindx ] = 0 ; 
  2273.     decr ( bufindx ) ; 
  2274.       } while ( ! ( bufindx == 0 ) ) ; 
  2275.       scannerstatus = 0 ; 
  2276.       warningindex = 0 ; 
  2277.       first = 1 ; 
  2278.       curinput .statefield = 33 ; 
  2279.       curinput .startfield = 1 ; 
  2280.       curinput .indexfield = 0 ; 
  2281.       line = 0 ; 
  2282.       curinput .namefield = 0 ; 
  2283.       forceeof = false ; 
  2284.       alignstate = 1000000L ; 
  2285.       if ( ! initterminal () ) 
  2286.       goto lab9999 ; 
  2287.       curinput .limitfield = last ; 
  2288.       first = last + 1 ; 
  2289.     } 
  2290.     if ( ( formatident == 0 ) || ( buffer [ curinput .locfield ] == 38 ) ) 
  2291.     {
  2292.       if ( formatident != 0 ) 
  2293.       initialize () ; 
  2294.       if ( ! openfmtfile () ) 
  2295.       goto lab9999 ; 
  2296.       if ( ! loadfmtfile () ) 
  2297.       {
  2298.     wclose ( fmtfile ) ; 
  2299.     goto lab9999 ; 
  2300.       } 
  2301.       wclose ( fmtfile ) ; 
  2302.       while ( ( curinput .locfield < curinput .limitfield ) && ( buffer [ 
  2303.       curinput .locfield ] == 32 ) ) incr ( curinput .locfield ) ; 
  2304.     } 
  2305.     if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  2306.     decr ( curinput .limitfield ) ; 
  2307.     else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  2308.     dateandtime ( eqtb [ 5287 ] .cint , eqtb [ 5288 ] .cint , eqtb [ 5289 ] 
  2309.     .cint , eqtb [ 5290 ] .cint ) ; 
  2310.     magicoffset = strstart [ 745 ] - 9 * 16 ; 
  2311.     if ( interaction == 0 ) 
  2312.     selector = 16 ; 
  2313.     else selector = 17 ; 
  2314.     if ( ( curinput .locfield < curinput .limitfield ) && ( eqtb [ 4627 + 
  2315.     buffer [ curinput .locfield ] ] .hh .v.RH != 0 ) ) 
  2316.     startinput () ; 
  2317.   } 
  2318.   initstrptr = strptr ; 
  2319.   initpoolptr = poolptr ; 
  2320.   history = 0 ; 
  2321.   maincontrol () ; 
  2322.   finalcleanup () ; 
  2323.   lab9998: closefilesandtermina () ; 
  2324.   lab9999: {
  2325.       
  2326.     termflush ( stdout ) ; 
  2327.     readyalready = 0 ; 
  2328.     if ( ( history != 0 ) && ( history != 1 ) ) {
  2329.       uexit ( 1 ) ; 
  2330.     } else {
  2331.       uexit ( 0 ) ; 
  2332.     }
  2333.   } 
  2334. } 
  2335.